← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: Martin Pool
  • Date: 2009-07-02 03:48:25 UTC
  • mto: This revision was merged to the branch mainline in revision 4502.
  • Revision ID: mbp@sourcefrog.net-20090702034825-2330z69r93a701ws
iter(i) returns i so we don't need a check

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transform.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
import os
18
18
import errno
19
19
from stat import S_ISREG, S_IEXEC
20
 
import time
21
20
 
22
21
from bzrlib.lazy_import import lazy_import
23
22
lazy_import(globals(), """
31
30
    multiparent,
32
31
    osutils,
33
32
    revision as _mod_revision,
34
 
    ui,
35
33
    )
36
34
""")
37
35
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
38
 
                           ReusingTransform, CantMoveRoot,
 
36
                           ReusingTransform, NotVersionedError, CantMoveRoot,
39
37
                           ExistingLimbo, ImmortalLimbo, NoFinalPath,
40
38
                           UnableCreateSymlink)
41
39
from bzrlib.filters import filtered_output_bytes, ContentFilterContext
50
48
    splitpath,
51
49
    supports_executable,
52
50
)
53
 
from bzrlib.progress import ProgressPhase
 
51
from bzrlib.progress import DummyProgress, ProgressPhase
54
52
from bzrlib.symbol_versioning import (
55
53
        deprecated_function,
56
54
        deprecated_in,
80
78
class TreeTransformBase(object):
81
79
    """The base class for TreeTransform and its kin."""
82
80
 
83
 
    def __init__(self, tree, pb=None,
 
81
    def __init__(self, tree, pb=DummyProgress(),
84
82
                 case_sensitive=True):
85
83
        """Constructor.
86
84
 
87
85
        :param tree: The tree that will be transformed, but not necessarily
88
86
            the output tree.
89
 
        :param pb: ignored
 
87
        :param pb: A ProgressBar indicating how much progress is being made
90
88
        :param case_sensitive: If True, the target of the transform is
91
89
            case sensitive, not just case preserving.
92
90
        """
163
161
 
164
162
    def adjust_path(self, name, parent, trans_id):
165
163
        """Change the path that is assigned to a transaction id."""
166
 
        if parent is None:
167
 
            raise ValueError("Parent trans-id may not be None")
168
164
        if trans_id == self._new_root:
169
165
            raise CantMoveRoot
170
166
        self._new_name[trans_id] = name
171
167
        self._new_parent[trans_id] = parent
 
168
        if parent == ROOT_PARENT:
 
169
            if self._new_root is not None:
 
170
                raise ValueError("Cannot have multiple roots.")
 
171
            self._new_root = trans_id
172
172
 
173
173
    def adjust_root_path(self, name, parent):
174
174
        """Emulate moving the root by moving all children, instead.
202
202
        self.version_file(old_root_file_id, old_root)
203
203
        self.unversion_file(self._new_root)
204
204
 
205
 
    def fixup_new_roots(self):
206
 
        """Reinterpret requests to change the root directory
207
 
 
208
 
        Instead of creating a root directory, or moving an existing directory,
209
 
        all the attributes and children of the new root are applied to the
210
 
        existing root directory.
211
 
 
212
 
        This means that the old root trans-id becomes obsolete, so it is
213
 
        recommended only to invoke this after the root trans-id has become
214
 
        irrelevant.
215
 
        """
216
 
        new_roots = [k for k, v in self._new_parent.iteritems() if v is
217
 
                     ROOT_PARENT]
218
 
        if len(new_roots) < 1:
219
 
            return
220
 
        if len(new_roots) != 1:
221
 
            raise ValueError('A tree cannot have two roots!')
222
 
        if self._new_root is None:
223
 
            self._new_root = new_roots[0]
224
 
            return
225
 
        old_new_root = new_roots[0]
226
 
        # TODO: What to do if a old_new_root is present, but self._new_root is
227
 
        #       not listed as being removed? This code explicitly unversions
228
 
        #       the old root and versions it with the new file_id. Though that
229
 
        #       seems like an incomplete delta
230
 
 
231
 
        # unversion the new root's directory.
232
 
        file_id = self.final_file_id(old_new_root)
233
 
        if old_new_root in self._new_id:
234
 
            self.cancel_versioning(old_new_root)
235
 
        else:
236
 
            self.unversion_file(old_new_root)
237
 
        # if, at this stage, root still has an old file_id, zap it so we can
238
 
        # stick a new one in.
239
 
        if (self.tree_file_id(self._new_root) is not None and
240
 
            self._new_root not in self._removed_id):
241
 
            self.unversion_file(self._new_root)
242
 
        self.version_file(file_id, self._new_root)
243
 
 
244
 
        # Now move children of new root into old root directory.
245
 
        # Ensure all children are registered with the transaction, but don't
246
 
        # use directly-- some tree children have new parents
247
 
        list(self.iter_tree_children(old_new_root))
248
 
        # Move all children of new root into old root directory.
249
 
        for child in self.by_parent().get(old_new_root, []):
250
 
            self.adjust_path(self.final_name(child), self._new_root, child)
251
 
 
252
 
        # Ensure old_new_root has no directory.
253
 
        if old_new_root in self._new_contents:
254
 
            self.cancel_creation(old_new_root)
255
 
        else:
256
 
            self.delete_contents(old_new_root)
257
 
 
258
 
        # prevent deletion of root directory.
259
 
        if self._new_root in self._removed_contents:
260
 
            self.cancel_deletion(self._new_root)
261
 
 
262
 
        # destroy path info for old_new_root.
263
 
        del self._new_parent[old_new_root]
264
 
        del self._new_name[old_new_root]
265
 
 
266
205
    def trans_id_tree_file_id(self, inventory_id):
267
206
        """Determine the transaction id of a working tree file.
268
207
 
314
253
 
315
254
    def delete_contents(self, trans_id):
316
255
        """Schedule the contents of a path entry for deletion"""
317
 
        # Ensure that the object exists in the WorkingTree, this will raise an
318
 
        # exception if there is a problem
319
256
        self.tree_kind(trans_id)
320
257
        self._removed_contents.add(trans_id)
321
258
 
505
442
        conflicts.extend(self._overwrite_conflicts())
506
443
        return conflicts
507
444
 
508
 
    def _check_malformed(self):
509
 
        conflicts = self.find_conflicts()
510
 
        if len(conflicts) != 0:
511
 
            raise MalformedTransform(conflicts=conflicts)
512
 
 
513
445
    def _add_tree_children(self):
514
446
        """Add all the children of all active parents to the known paths.
515
447
 
922
854
    def get_preview_tree(self):
923
855
        """Return a tree representing the result of the transform.
924
856
 
925
 
        The tree is a snapshot, and altering the TreeTransform will invalidate
926
 
        it.
 
857
        This tree only supports the subset of Tree functionality required
 
858
        by show_diff_trees.  It must only be compared to tt._tree.
927
859
        """
928
860
        return _PreviewTree(self)
929
861
 
930
 
    def commit(self, branch, message, merge_parents=None, strict=False):
931
 
        """Commit the result of this TreeTransform to a branch.
932
 
 
933
 
        :param branch: The branch to commit to.
934
 
        :param message: The message to attach to the commit.
935
 
        :param merge_parents: Additional parents specified by pending merges.
936
 
        :return: The revision_id of the revision committed.
937
 
        """
938
 
        self._check_malformed()
939
 
        if strict:
940
 
            unversioned = set(self._new_contents).difference(set(self._new_id))
941
 
            for trans_id in unversioned:
942
 
                if self.final_file_id(trans_id) is None:
943
 
                    raise errors.StrictCommitFailed()
944
 
 
945
 
        revno, last_rev_id = branch.last_revision_info()
946
 
        if last_rev_id == _mod_revision.NULL_REVISION:
947
 
            if merge_parents is not None:
948
 
                raise ValueError('Cannot supply merge parents for first'
949
 
                                 ' commit.')
950
 
            parent_ids = []
951
 
        else:
952
 
            parent_ids = [last_rev_id]
953
 
            if merge_parents is not None:
954
 
                parent_ids.extend(merge_parents)
955
 
        if self._tree.get_revision_id() != last_rev_id:
956
 
            raise ValueError('TreeTransform not based on branch basis: %s' %
957
 
                             self._tree.get_revision_id())
958
 
        builder = branch.get_commit_builder(parent_ids)
959
 
        preview = self.get_preview_tree()
960
 
        list(builder.record_iter_changes(preview, last_rev_id,
961
 
                                         self.iter_changes()))
962
 
        builder.finish_inventory()
963
 
        revision_id = builder.commit(message)
964
 
        branch.set_last_revision_info(revno + 1, revision_id)
965
 
        return revision_id
966
 
 
967
862
    def _text_parent(self, trans_id):
968
863
        file_id = self.tree_file_id(trans_id)
969
864
        try:
1063
958
class DiskTreeTransform(TreeTransformBase):
1064
959
    """Tree transform storing its contents on disk."""
1065
960
 
1066
 
    def __init__(self, tree, limbodir, pb=None,
 
961
    def __init__(self, tree, limbodir, pb=DummyProgress(),
1067
962
                 case_sensitive=True):
1068
963
        """Constructor.
1069
964
        :param tree: The tree that will be transformed, but not necessarily
1070
965
            the output tree.
1071
966
        :param limbodir: A directory where new files can be stored until
1072
967
            they are installed in their proper places
1073
 
        :param pb: ignored
 
968
        :param pb: A ProgressBar indicating how much progress is being made
1074
969
        :param case_sensitive: If True, the target of the transform is
1075
970
            case sensitive, not just case preserving.
1076
971
        """
1086
981
        self._limbo_children_names = {}
1087
982
        # List of transform ids that need to be renamed from limbo into place
1088
983
        self._needs_rename = set()
1089
 
        self._creation_mtime = None
1090
984
 
1091
985
    def finalize(self):
1092
986
        """Release the working tree lock, if held, clean up limbo dir.
1118
1012
    def _limbo_name(self, trans_id):
1119
1013
        """Generate the limbo name of a file"""
1120
1014
        limbo_name = self._limbo_files.get(trans_id)
1121
 
        if limbo_name is None:
1122
 
            limbo_name = self._generate_limbo_path(trans_id)
1123
 
            self._limbo_files[trans_id] = limbo_name
 
1015
        if limbo_name is not None:
 
1016
            return limbo_name
 
1017
        parent = self._new_parent.get(trans_id)
 
1018
        # if the parent directory is already in limbo (e.g. when building a
 
1019
        # tree), choose a limbo name inside the parent, to reduce further
 
1020
        # renames.
 
1021
        use_direct_path = False
 
1022
        if self._new_contents.get(parent) == 'directory':
 
1023
            filename = self._new_name.get(trans_id)
 
1024
            if filename is not None:
 
1025
                if parent not in self._limbo_children:
 
1026
                    self._limbo_children[parent] = set()
 
1027
                    self._limbo_children_names[parent] = {}
 
1028
                    use_direct_path = True
 
1029
                # the direct path can only be used if no other file has
 
1030
                # already taken this pathname, i.e. if the name is unused, or
 
1031
                # if it is already associated with this trans_id.
 
1032
                elif self._case_sensitive_target:
 
1033
                    if (self._limbo_children_names[parent].get(filename)
 
1034
                        in (trans_id, None)):
 
1035
                        use_direct_path = True
 
1036
                else:
 
1037
                    for l_filename, l_trans_id in\
 
1038
                        self._limbo_children_names[parent].iteritems():
 
1039
                        if l_trans_id == trans_id:
 
1040
                            continue
 
1041
                        if l_filename.lower() == filename.lower():
 
1042
                            break
 
1043
                    else:
 
1044
                        use_direct_path = True
 
1045
 
 
1046
        if use_direct_path:
 
1047
            limbo_name = pathjoin(self._limbo_files[parent], filename)
 
1048
            self._limbo_children[parent].add(trans_id)
 
1049
            self._limbo_children_names[parent][filename] = trans_id
 
1050
        else:
 
1051
            limbo_name = pathjoin(self._limbodir, trans_id)
 
1052
            self._needs_rename.add(trans_id)
 
1053
        self._limbo_files[trans_id] = limbo_name
1124
1054
        return limbo_name
1125
1055
 
1126
 
    def _generate_limbo_path(self, trans_id):
1127
 
        """Generate a limbo path using the trans_id as the relative path.
1128
 
 
1129
 
        This is suitable as a fallback, and when the transform should not be
1130
 
        sensitive to the path encoding of the limbo directory.
1131
 
        """
1132
 
        self._needs_rename.add(trans_id)
1133
 
        return pathjoin(self._limbodir, trans_id)
1134
 
 
1135
1056
    def adjust_path(self, name, parent, trans_id):
1136
1057
        previous_parent = self._new_parent.get(trans_id)
1137
1058
        previous_name = self._new_name.get(trans_id)
1139
1060
        if (trans_id in self._limbo_files and
1140
1061
            trans_id not in self._needs_rename):
1141
1062
            self._rename_in_limbo([trans_id])
1142
 
            if previous_parent != parent:
1143
 
                self._limbo_children[previous_parent].remove(trans_id)
1144
 
            if previous_parent != parent or previous_name != name:
1145
 
                del self._limbo_children_names[previous_parent][previous_name]
 
1063
            self._limbo_children[previous_parent].remove(trans_id)
 
1064
            del self._limbo_children_names[previous_parent][previous_name]
1146
1065
 
1147
1066
    def _rename_in_limbo(self, trans_ids):
1148
1067
        """Fix limbo names so that the right final path is produced.
1160
1079
            if trans_id not in self._new_contents:
1161
1080
                continue
1162
1081
            new_path = self._limbo_name(trans_id)
1163
 
            osutils.rename(old_path, new_path)
1164
 
            for descendant in self._limbo_descendants(trans_id):
1165
 
                desc_path = self._limbo_files[descendant]
1166
 
                desc_path = new_path + desc_path[len(old_path):]
1167
 
                self._limbo_files[descendant] = desc_path
1168
 
 
1169
 
    def _limbo_descendants(self, trans_id):
1170
 
        """Return the set of trans_ids whose limbo paths descend from this."""
1171
 
        descendants = set(self._limbo_children.get(trans_id, []))
1172
 
        for descendant in list(descendants):
1173
 
            descendants.update(self._limbo_descendants(descendant))
1174
 
        return descendants
 
1082
            os.rename(old_path, new_path)
1175
1083
 
1176
1084
    def create_file(self, contents, trans_id, mode_id=None):
1177
1085
        """Schedule creation of a new file.
1199
1107
            f.writelines(contents)
1200
1108
        finally:
1201
1109
            f.close()
1202
 
        self._set_mtime(name)
1203
1110
        self._set_mode(trans_id, mode_id, S_ISREG)
1204
1111
 
1205
1112
    def _read_file_chunks(self, trans_id):
1212
1119
    def _read_symlink_target(self, trans_id):
1213
1120
        return os.readlink(self._limbo_name(trans_id))
1214
1121
 
1215
 
    def _set_mtime(self, path):
1216
 
        """All files that are created get the same mtime.
1217
 
 
1218
 
        This time is set by the first object to be created.
1219
 
        """
1220
 
        if self._creation_mtime is None:
1221
 
            self._creation_mtime = time.time()
1222
 
        os.utime(path, (self._creation_mtime, self._creation_mtime))
1223
 
 
1224
1122
    def create_hardlink(self, path, trans_id):
1225
1123
        """Schedule creation of a hard link"""
1226
1124
        name = self._limbo_name(trans_id)
1340
1238
    FileMover does not delete files until it is sure that a rollback will not
1341
1239
    happen.
1342
1240
    """
1343
 
    def __init__(self, tree, pb=None):
 
1241
    def __init__(self, tree, pb=DummyProgress()):
1344
1242
        """Note: a tree_write lock is taken on the tree.
1345
1243
 
1346
1244
        Use TreeTransform.finalize() to release the lock (can be omitted if
1456
1354
                continue
1457
1355
            yield self.trans_id_tree_path(childpath)
1458
1356
 
1459
 
    def _generate_limbo_path(self, trans_id):
1460
 
        """Generate a limbo path using the final path if possible.
1461
 
 
1462
 
        This optimizes the performance of applying the tree transform by
1463
 
        avoiding renames.  These renames can be avoided only when the parent
1464
 
        directory is already scheduled for creation.
1465
 
 
1466
 
        If the final path cannot be used, falls back to using the trans_id as
1467
 
        the relpath.
1468
 
        """
1469
 
        parent = self._new_parent.get(trans_id)
1470
 
        # if the parent directory is already in limbo (e.g. when building a
1471
 
        # tree), choose a limbo name inside the parent, to reduce further
1472
 
        # renames.
1473
 
        use_direct_path = False
1474
 
        if self._new_contents.get(parent) == 'directory':
1475
 
            filename = self._new_name.get(trans_id)
1476
 
            if filename is not None:
1477
 
                if parent not in self._limbo_children:
1478
 
                    self._limbo_children[parent] = set()
1479
 
                    self._limbo_children_names[parent] = {}
1480
 
                    use_direct_path = True
1481
 
                # the direct path can only be used if no other file has
1482
 
                # already taken this pathname, i.e. if the name is unused, or
1483
 
                # if it is already associated with this trans_id.
1484
 
                elif self._case_sensitive_target:
1485
 
                    if (self._limbo_children_names[parent].get(filename)
1486
 
                        in (trans_id, None)):
1487
 
                        use_direct_path = True
1488
 
                else:
1489
 
                    for l_filename, l_trans_id in\
1490
 
                        self._limbo_children_names[parent].iteritems():
1491
 
                        if l_trans_id == trans_id:
1492
 
                            continue
1493
 
                        if l_filename.lower() == filename.lower():
1494
 
                            break
1495
 
                    else:
1496
 
                        use_direct_path = True
1497
 
 
1498
 
        if not use_direct_path:
1499
 
            return DiskTreeTransform._generate_limbo_path(self, trans_id)
1500
 
 
1501
 
        limbo_name = pathjoin(self._limbo_files[parent], filename)
1502
 
        self._limbo_children[parent].add(trans_id)
1503
 
        self._limbo_children_names[parent][filename] = trans_id
1504
 
        return limbo_name
1505
 
 
1506
1357
 
1507
1358
    def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
1508
1359
        """Apply all changes to the inventory and filesystem.
1519
1370
        :param _mover: Supply an alternate FileMover, for testing
1520
1371
        """
1521
1372
        if not no_conflicts:
1522
 
            self._check_malformed()
 
1373
            conflicts = self.find_conflicts()
 
1374
            if len(conflicts) != 0:
 
1375
                raise MalformedTransform(conflicts=conflicts)
1523
1376
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1524
1377
        try:
1525
1378
            if precomputed_delta is None:
1629
1482
                child_pb.update('removing file', num, len(tree_paths))
1630
1483
                full_path = self._tree.abspath(path)
1631
1484
                if trans_id in self._removed_contents:
1632
 
                    delete_path = os.path.join(self._deletiondir, trans_id)
1633
 
                    mover.pre_delete(full_path, delete_path)
1634
 
                elif (trans_id in self._new_name
1635
 
                      or trans_id in self._new_parent):
 
1485
                    mover.pre_delete(full_path, os.path.join(self._deletiondir,
 
1486
                                     trans_id))
 
1487
                elif trans_id in self._new_name or trans_id in \
 
1488
                    self._new_parent:
1636
1489
                    try:
1637
1490
                        mover.rename(full_path, self._limbo_name(trans_id))
1638
1491
                    except OSError, e:
1692
1545
    unversioned files in the input tree.
1693
1546
    """
1694
1547
 
1695
 
    def __init__(self, tree, pb=None, case_sensitive=True):
 
1548
    def __init__(self, tree, pb=DummyProgress(), case_sensitive=True):
1696
1549
        tree.lock_read()
1697
1550
        limbodir = osutils.mkdtemp(prefix='bzr-limbo-')
1698
1551
        DiskTreeTransform.__init__(self, tree, limbodir, pb, case_sensitive)
1743
1596
        self._all_children_cache = {}
1744
1597
        self._path2trans_id_cache = {}
1745
1598
        self._final_name_cache = {}
1746
 
        self._iter_changes_cache = dict((c[0], c) for c in
1747
 
                                        self._transform.iter_changes())
 
1599
 
 
1600
    def _changes(self, file_id):
 
1601
        for changes in self._transform.iter_changes():
 
1602
            if changes[0] == file_id:
 
1603
                return changes
1748
1604
 
1749
1605
    def _content_change(self, file_id):
1750
1606
        """Return True if the content of this file changed"""
1751
 
        changes = self._iter_changes_cache.get(file_id)
 
1607
        changes = self._changes(file_id)
1752
1608
        # changes[2] is true if the file content changed.  See
1753
1609
        # InterTree.iter_changes.
1754
1610
        return (changes is not None and changes[2])
1798
1654
            executable = self.is_executable(file_id, path)
1799
1655
        return kind, executable, None
1800
1656
 
1801
 
    def is_locked(self):
1802
 
        return False
1803
 
 
1804
1657
    def lock_read(self):
1805
1658
        # Perhaps in theory, this should lock the TreeTransform?
1806
 
        return self
 
1659
        pass
1807
1660
 
1808
1661
    def unlock(self):
1809
1662
        pass
1826
1679
    def __iter__(self):
1827
1680
        return iter(self.all_file_ids())
1828
1681
 
1829
 
    def _has_id(self, file_id, fallback_check):
 
1682
    def has_id(self, file_id):
1830
1683
        if file_id in self._transform._r_new_id:
1831
1684
            return True
1832
1685
        elif file_id in set([self._transform.tree_file_id(trans_id) for
1833
1686
            trans_id in self._transform._removed_id]):
1834
1687
            return False
1835
1688
        else:
1836
 
            return fallback_check(file_id)
1837
 
 
1838
 
    def has_id(self, file_id):
1839
 
        return self._has_id(file_id, self._transform._tree.has_id)
1840
 
 
1841
 
    def has_or_had_id(self, file_id):
1842
 
        return self._has_id(file_id, self._transform._tree.has_or_had_id)
 
1689
            return self._transform._tree.has_id(file_id)
1843
1690
 
1844
1691
    def _path2trans_id(self, path):
1845
1692
        # We must not use None here, because that is a valid value to store.
1898
1745
            if self._transform.final_file_id(trans_id) is None:
1899
1746
                yield self._final_paths._determine_path(trans_id)
1900
1747
 
1901
 
    def _make_inv_entries(self, ordered_entries, specific_file_ids=None,
1902
 
        yield_parents=False):
 
1748
    def _make_inv_entries(self, ordered_entries, specific_file_ids=None):
1903
1749
        for trans_id, parent_file_id in ordered_entries:
1904
1750
            file_id = self._transform.final_file_id(trans_id)
1905
1751
            if file_id is None:
1931
1777
                ordered_ids.append((trans_id, parent_file_id))
1932
1778
        return ordered_ids
1933
1779
 
1934
 
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
 
1780
    def iter_entries_by_dir(self, specific_file_ids=None):
1935
1781
        # This may not be a maximally efficient implementation, but it is
1936
1782
        # reasonably straightforward.  An implementation that grafts the
1937
1783
        # TreeTransform changes onto the tree's iter_entries_by_dir results
1939
1785
        # position.
1940
1786
        ordered_ids = self._list_files_by_dir()
1941
1787
        for entry, trans_id in self._make_inv_entries(ordered_ids,
1942
 
            specific_file_ids, yield_parents=yield_parents):
 
1788
                                                      specific_file_ids):
1943
1789
            yield unicode(self._final_paths.get_path(trans_id)), entry
1944
1790
 
1945
1791
    def _iter_entries_for_dir(self, dir_path):
1992
1838
    def get_file_mtime(self, file_id, path=None):
1993
1839
        """See Tree.get_file_mtime"""
1994
1840
        if not self._content_change(file_id):
1995
 
            return self._transform._tree.get_file_mtime(file_id)
 
1841
            return self._transform._tree.get_file_mtime(file_id, path)
1996
1842
        return self._stat_limbo_file(file_id).st_mtime
1997
1843
 
1998
1844
    def _file_size(self, entry, stat_value):
2052
1898
                statval = os.lstat(limbo_name)
2053
1899
                size = statval.st_size
2054
1900
                if not supports_executable():
2055
 
                    executable = False
 
1901
                    executable = None
2056
1902
                else:
2057
1903
                    executable = statval.st_mode & S_IEXEC
2058
1904
            else:
2060
1906
                executable = None
2061
1907
            if kind == 'symlink':
2062
1908
                link_or_sha1 = os.readlink(limbo_name).decode(osutils._fs_enc)
2063
 
        executable = tt._new_executability.get(trans_id, executable)
 
1909
        if supports_executable():
 
1910
            executable = tt._new_executability.get(trans_id, executable)
2064
1911
        return kind, size, executable, link_or_sha1
2065
1912
 
2066
1913
    def iter_changes(self, from_tree, include_unchanged=False,
2097
1944
 
2098
1945
    def annotate_iter(self, file_id,
2099
1946
                      default_revision=_mod_revision.CURRENT_REVISION):
2100
 
        changes = self._iter_changes_cache.get(file_id)
 
1947
        changes = self._changes(file_id)
2101
1948
        if changes is None:
2102
1949
            get_old = True
2103
1950
        else:
2115
1962
            return old_annotation
2116
1963
        if not changed_content:
2117
1964
            return old_annotation
2118
 
        # TODO: This is doing something similar to what WT.annotate_iter is
2119
 
        #       doing, however it fails slightly because it doesn't know what
2120
 
        #       the *other* revision_id is, so it doesn't know how to give the
2121
 
        #       other as the origin for some lines, they all get
2122
 
        #       'default_revision'
2123
 
        #       It would be nice to be able to use the new Annotator based
2124
 
        #       approach, as well.
2125
1965
        return annotate.reannotate([old_annotation],
2126
1966
                                   self.get_file(file_id).readlines(),
2127
1967
                                   default_revision)
2193
2033
        self.transform = transform
2194
2034
 
2195
2035
    def _determine_path(self, trans_id):
2196
 
        if (trans_id == self.transform.root or trans_id == ROOT_PARENT):
 
2036
        if trans_id == self.transform.root:
2197
2037
            return ""
2198
2038
        name = self.transform.final_name(trans_id)
2199
2039
        parent_id = self.transform.final_parent(trans_id)
2379
2219
        new_desired_files = desired_files
2380
2220
    else:
2381
2221
        iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
2382
 
        unchanged = [(f, p[1]) for (f, p, c, v, d, n, k, e)
2383
 
                     in iter if not (c or e[0] != e[1])]
2384
 
        if accelerator_tree.supports_content_filtering():
2385
 
            unchanged = [(f, p) for (f, p) in unchanged
2386
 
                         if not accelerator_tree.iter_search_rules([p]).next()]
2387
 
        unchanged = dict(unchanged)
 
2222
        unchanged = dict((f, p[1]) for (f, p, c, v, d, n, k, e)
 
2223
                         in iter if not (c or e[0] != e[1]))
2388
2224
        new_desired_files = []
2389
2225
        count = 0
2390
2226
        for file_id, (trans_id, tree_path) in desired_files:
2513
2349
        tt.create_directory(trans_id)
2514
2350
 
2515
2351
 
2516
 
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2517
 
    filter_tree_path=None):
2518
 
    """Create new file contents according to tree contents.
2519
 
    
2520
 
    :param filter_tree_path: the tree path to use to lookup
2521
 
      content filters to apply to the bytes output in the working tree.
2522
 
      This only applies if the working tree supports content filtering.
2523
 
    """
 
2352
def create_from_tree(tt, trans_id, tree, file_id, bytes=None):
 
2353
    """Create new file contents according to tree contents."""
2524
2354
    kind = tree.kind(file_id)
2525
2355
    if kind == 'directory':
2526
2356
        tt.create_directory(trans_id)
2531
2361
                bytes = tree_file.readlines()
2532
2362
            finally:
2533
2363
                tree_file.close()
2534
 
        wt = tt._tree
2535
 
        if wt.supports_content_filtering() and filter_tree_path is not None:
2536
 
            filters = wt._content_filter_stack(filter_tree_path)
2537
 
            bytes = filtered_output_bytes(bytes, filters,
2538
 
                ContentFilterContext(filter_tree_path, tree))
2539
2364
        tt.create_file(bytes, trans_id)
2540
2365
    elif kind == "symlink":
2541
2366
        tt.create_symlink(tree.get_symlink_target(file_id), trans_id)
2593
2418
 
2594
2419
 
2595
2420
def revert(working_tree, target_tree, filenames, backups=False,
2596
 
           pb=None, change_reporter=None):
 
2421
           pb=DummyProgress(), change_reporter=None):
2597
2422
    """Revert a working tree's contents to those of a target tree."""
2598
2423
    target_tree.lock_read()
2599
 
    pb = ui.ui_factory.nested_progress_bar()
2600
2424
    tt = TreeTransform(working_tree, pb)
2601
2425
    try:
2602
2426
        pp = ProgressPhase("Revert phase", 3, pb)
2621
2445
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2622
2446
                              backups, pp, basis_tree=None,
2623
2447
                              merge_modified=None):
 
2448
    pp.next_phase()
2624
2449
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2625
2450
    try:
2626
2451
        if merge_modified is None:
2630
2455
                                      merge_modified, basis_tree)
2631
2456
    finally:
2632
2457
        child_pb.finished()
 
2458
    pp.next_phase()
2633
2459
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2634
2460
    try:
2635
2461
        raw_conflicts = resolve_conflicts(tt, child_pb,
2728
2554
                    parent_trans = ROOT_PARENT
2729
2555
                else:
2730
2556
                    parent_trans = tt.trans_id_file_id(parent[1])
2731
 
                if parent[0] is None and versioned[0]:
2732
 
                    tt.adjust_root_path(name[1], parent_trans)
2733
 
                else:
2734
 
                    tt.adjust_path(name[1], parent_trans, trans_id)
 
2557
                tt.adjust_path(name[1], parent_trans, trans_id)
2735
2558
            if executable[0] != executable[1] and kind[1] == "file":
2736
2559
                tt.set_executability(executable[1], trans_id)
2737
 
        if working_tree.supports_content_filtering():
2738
 
            for index, ((trans_id, mode_id), bytes) in enumerate(
2739
 
                target_tree.iter_files_bytes(deferred_files)):
2740
 
                file_id = deferred_files[index][0]
2741
 
                # We're reverting a tree to the target tree so using the
2742
 
                # target tree to find the file path seems the best choice
2743
 
                # here IMO - Ian C 27/Oct/2009
2744
 
                filter_tree_path = target_tree.id2path(file_id)
2745
 
                filters = working_tree._content_filter_stack(filter_tree_path)
2746
 
                bytes = filtered_output_bytes(bytes, filters,
2747
 
                    ContentFilterContext(filter_tree_path, working_tree))
2748
 
                tt.create_file(bytes, trans_id, mode_id)
2749
 
        else:
2750
 
            for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
2751
 
                deferred_files):
2752
 
                tt.create_file(bytes, trans_id, mode_id)
2753
 
        tt.fixup_new_roots()
 
2560
        for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
 
2561
            deferred_files):
 
2562
            tt.create_file(bytes, trans_id, mode_id)
2754
2563
    finally:
2755
2564
        if basis_tree is not None:
2756
2565
            basis_tree.unlock()
2757
2566
    return merge_modified
2758
2567
 
2759
2568
 
2760
 
def resolve_conflicts(tt, pb=None, pass_func=None):
 
2569
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
2761
2570
    """Make many conflict-resolution attempts, but die if they fail"""
2762
2571
    if pass_func is None:
2763
2572
        pass_func = conflict_pass
2764
2573
    new_conflicts = set()
2765
 
    pb = ui.ui_factory.nested_progress_bar()
2766
2574
    try:
2767
2575
        for n in range(10):
2768
2576
            pb.update('Resolution pass', n+1, 10)
2772
2580
            new_conflicts.update(pass_func(tt, conflicts))
2773
2581
        raise MalformedTransform(conflicts=conflicts)
2774
2582
    finally:
2775
 
        pb.finished()
 
2583
        pb.clear()
2776
2584
 
2777
2585
 
2778
2586
def conflict_pass(tt, conflicts, path_tree=None):
2827
2635
                        # special-case the other tree root (move its
2828
2636
                        # children to current root)
2829
2637
                        if entry.parent_id is None:
2830
 
                            create = False
 
2638
                            create=False
2831
2639
                            moved = _reparent_transform_children(
2832
2640
                                tt, trans_id, tt.root)
2833
2641
                            for child in moved:
2901
2709
        self.pending_deletions = []
2902
2710
 
2903
2711
    def rename(self, from_, to):
2904
 
        """Rename a file from one path to another."""
 
2712
        """Rename a file from one path to another.  Functions like os.rename"""
2905
2713
        try:
2906
 
            osutils.rename(from_, to)
 
2714
            os.rename(from_, to)
2907
2715
        except OSError, e:
2908
2716
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
2909
2717
                raise errors.FileExists(to, str(e))
2923
2731
    def rollback(self):
2924
2732
        """Reverse all renames that have been performed"""
2925
2733
        for from_, to in reversed(self.past_renames):
2926
 
            osutils.rename(to, from_)
 
2734
            os.rename(to, from_)
2927
2735
        # after rollback, don't reuse _FileMover
2928
2736
        past_renames = None
2929
2737
        pending_deletions = None