/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: Jared Bunting
  • Date: 2010-10-21 22:27:43 UTC
  • mto: This revision was merged to the branch mainline in revision 5514.
  • Revision ID: jared.bunting@peachjean.com-20101021222743-tn9n0cgzg3z8cb25
Changed _win32_local_path_from_url to not allow "file:///C:" form.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transform.py
19
19
from stat import S_ISREG, S_IEXEC
20
20
import time
21
21
 
22
 
from bzrlib.lazy_import import lazy_import
23
 
lazy_import(globals(), """
 
22
from bzrlib import (
 
23
    errors,
 
24
    lazy_import,
 
25
    registry,
 
26
    )
 
27
lazy_import.lazy_import(globals(), """
24
28
from bzrlib import (
25
29
    annotate,
26
30
    bencode,
27
31
    bzrdir,
 
32
    commit,
28
33
    delta,
29
34
    errors,
30
35
    inventory,
31
36
    multiparent,
32
37
    osutils,
33
38
    revision as _mod_revision,
 
39
    trace,
34
40
    ui,
35
41
    )
36
42
""")
54
60
from bzrlib.symbol_versioning import (
55
61
        deprecated_function,
56
62
        deprecated_in,
 
63
        deprecated_method,
57
64
        )
58
65
from bzrlib.trace import mutter, warning
59
66
from bzrlib import tree
63
70
 
64
71
ROOT_PARENT = "root-parent"
65
72
 
66
 
 
67
73
def unique_add(map, key, value):
68
74
    if key in map:
69
75
        raise DuplicateKey(key=key)
70
76
    map[key] = value
71
77
 
72
78
 
 
79
 
73
80
class _TransformResults(object):
74
81
    def __init__(self, modified_paths, rename_count):
75
82
        object.__init__(self)
314
321
 
315
322
    def delete_contents(self, trans_id):
316
323
        """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
 
        self.tree_kind(trans_id)
320
 
        self._removed_contents.add(trans_id)
 
324
        kind = self.tree_kind(trans_id)
 
325
        if kind is not None:
 
326
            self._removed_contents.add(trans_id)
321
327
 
322
328
    def cancel_deletion(self, trans_id):
323
329
        """Cancel a scheduled deletion"""
388
394
        changed_kind = set(self._removed_contents)
389
395
        changed_kind.intersection_update(self._new_contents)
390
396
        changed_kind.difference_update(new_ids)
391
 
        changed_kind = (t for t in changed_kind if self.tree_kind(t) !=
392
 
                        self.final_kind(t))
 
397
        changed_kind = (t for t in changed_kind
 
398
                        if self.tree_kind(t) != self.final_kind(t))
393
399
        new_ids.update(changed_kind)
394
400
        return sorted(FinalPaths(self).get_paths(new_ids))
395
401
 
396
402
    def final_kind(self, trans_id):
397
403
        """Determine the final file kind, after any changes applied.
398
404
 
399
 
        Raises NoSuchFile if the file does not exist/has no contents.
400
 
        (It is conceivable that a path would be created without the
401
 
        corresponding contents insertion command)
 
405
        :return: None if the file does not exist/has no contents.  (It is
 
406
            conceivable that a path would be created without the corresponding
 
407
            contents insertion command)
402
408
        """
403
409
        if trans_id in self._new_contents:
404
410
            return self._new_contents[trans_id]
405
411
        elif trans_id in self._removed_contents:
406
 
            raise NoSuchFile(None)
 
412
            return None
407
413
        else:
408
414
            return self.tree_kind(trans_id)
409
415
 
531
537
            # ensure that all children are registered with the transaction
532
538
            list(self.iter_tree_children(parent_id))
533
539
 
 
540
    @deprecated_method(deprecated_in((2, 3, 0)))
534
541
    def has_named_child(self, by_parent, parent_id, name):
535
 
        try:
536
 
            children = by_parent[parent_id]
537
 
        except KeyError:
538
 
            children = []
539
 
        for child in children:
 
542
        return self._has_named_child(
 
543
            name, parent_id, known_children=by_parent.get(parent_id, []))
 
544
 
 
545
    def _has_named_child(self, name, parent_id, known_children):
 
546
        """Does a parent already have a name child.
 
547
 
 
548
        :param name: The searched for name.
 
549
 
 
550
        :param parent_id: The parent for which the check is made.
 
551
 
 
552
        :param known_children: The already known children. This should have
 
553
            been recently obtained from `self.by_parent.get(parent_id)`
 
554
            (or will be if None is passed).
 
555
        """
 
556
        if known_children is None:
 
557
            known_children = self.by_parent().get(parent_id, [])
 
558
        for child in known_children:
540
559
            if self.final_name(child) == name:
541
560
                return True
542
 
        try:
543
 
            path = self._tree_id_paths[parent_id]
544
 
        except KeyError:
 
561
        parent_path = self._tree_id_paths.get(parent_id, None)
 
562
        if parent_path is None:
 
563
            # No parent... no children
545
564
            return False
546
 
        childpath = joinpath(path, name)
547
 
        child_id = self._tree_path_ids.get(childpath)
 
565
        child_path = joinpath(parent_path, name)
 
566
        child_id = self._tree_path_ids.get(child_path, None)
548
567
        if child_id is None:
549
 
            return lexists(self._tree.abspath(childpath))
 
568
            # Not known by the tree transform yet, check the filesystem
 
569
            return osutils.lexists(self._tree.abspath(child_path))
550
570
        else:
551
 
            if self.final_parent(child_id) != parent_id:
552
 
                return False
553
 
            if child_id in self._removed_contents:
554
 
                # XXX What about dangling file-ids?
555
 
                return False
556
 
            else:
557
 
                return True
 
571
            raise AssertionError('child_id is missing: %s, %s, %s'
 
572
                                 % (name, parent_id, child_id))
 
573
 
 
574
    def _available_backup_name(self, name, target_id):
 
575
        """Find an available backup name.
 
576
 
 
577
        :param name: The basename of the file.
 
578
 
 
579
        :param target_id: The directory trans_id where the backup should 
 
580
            be placed.
 
581
        """
 
582
        known_children = self.by_parent().get(target_id, [])
 
583
        return osutils.available_backup_name(
 
584
            name,
 
585
            lambda base: self._has_named_child(
 
586
                base, target_id, known_children))
558
587
 
559
588
    def _parent_loops(self):
560
589
        """No entry should be its own ancestor"""
595
624
        """
596
625
        conflicts = []
597
626
        for trans_id in self._new_id.iterkeys():
598
 
            try:
599
 
                kind = self.final_kind(trans_id)
600
 
            except NoSuchFile:
 
627
            kind = self.final_kind(trans_id)
 
628
            if kind is None:
601
629
                conflicts.append(('versioning no contents', trans_id))
602
630
                continue
603
631
            if not InventoryEntry.versionable_kind(kind):
617
645
            if self.final_file_id(trans_id) is None:
618
646
                conflicts.append(('unversioned executability', trans_id))
619
647
            else:
620
 
                try:
621
 
                    non_file = self.final_kind(trans_id) != "file"
622
 
                except NoSuchFile:
623
 
                    non_file = True
624
 
                if non_file is True:
 
648
                if self.final_kind(trans_id) != "file":
625
649
                    conflicts.append(('non-file executability', trans_id))
626
650
        return conflicts
627
651
 
629
653
        """Check for overwrites (not permitted on Win32)"""
630
654
        conflicts = []
631
655
        for trans_id in self._new_contents:
632
 
            try:
633
 
                self.tree_kind(trans_id)
634
 
            except NoSuchFile:
 
656
            if self.tree_kind(trans_id) is None:
635
657
                continue
636
658
            if trans_id not in self._removed_contents:
637
659
                conflicts.append(('overwrite', trans_id,
651
673
            last_name = None
652
674
            last_trans_id = None
653
675
            for name, trans_id in name_ids:
654
 
                try:
655
 
                    kind = self.final_kind(trans_id)
656
 
                except NoSuchFile:
657
 
                    kind = None
 
676
                kind = self.final_kind(trans_id)
658
677
                file_id = self.final_file_id(trans_id)
659
678
                if kind is None and file_id is None:
660
679
                    continue
686
705
                continue
687
706
            if not self._any_contents(children):
688
707
                continue
689
 
            for child in children:
690
 
                try:
691
 
                    self.final_kind(child)
692
 
                except NoSuchFile:
693
 
                    continue
694
 
            try:
695
 
                kind = self.final_kind(parent_id)
696
 
            except NoSuchFile:
697
 
                kind = None
 
708
            kind = self.final_kind(parent_id)
698
709
            if kind is None:
699
710
                conflicts.append(('missing parent', parent_id))
700
711
            elif kind != "directory":
704
715
    def _any_contents(self, trans_ids):
705
716
        """Return true if any of the trans_ids, will have contents."""
706
717
        for trans_id in trans_ids:
707
 
            try:
708
 
                kind = self.final_kind(trans_id)
709
 
            except NoSuchFile:
710
 
                continue
711
 
            return True
 
718
            if self.final_kind(trans_id) is not None:
 
719
                return True
712
720
        return False
713
721
 
714
722
    def _set_executability(self, path, trans_id):
780
788
        self.create_symlink(target, trans_id)
781
789
        return trans_id
782
790
 
 
791
    def new_orphan(self, trans_id, parent_id):
 
792
        """Schedule an item to be orphaned.
 
793
 
 
794
        When a directory is about to be removed, its children, if they are not
 
795
        versioned are moved out of the way: they don't have a parent anymore.
 
796
 
 
797
        :param trans_id: The trans_id of the existing item.
 
798
        :param parent_id: The parent trans_id of the item.
 
799
        """
 
800
        raise NotImplementedError(self.new_orphan)
 
801
 
 
802
    def _get_potential_orphans(self, dir_id):
 
803
        """Find the potential orphans in a directory.
 
804
 
 
805
        A directory can't be safely deleted if there are versioned files in it.
 
806
        If all the contained files are unversioned then they can be orphaned.
 
807
 
 
808
        The 'None' return value means that the directory contains at least one
 
809
        versioned file and should not be deleted.
 
810
 
 
811
        :param dir_id: The directory trans id.
 
812
 
 
813
        :return: A list of the orphan trans ids or None if at least one
 
814
             versioned file is present.
 
815
        """
 
816
        orphans = []
 
817
        # Find the potential orphans, stop if one item should be kept
 
818
        for c in self.by_parent()[dir_id]:
 
819
            if self.final_file_id(c) is None:
 
820
                orphans.append(c)
 
821
            else:
 
822
                # We have a versioned file here, searching for orphans is
 
823
                # meaningless.
 
824
                orphans = None
 
825
                break
 
826
        return orphans
 
827
 
783
828
    def _affected_ids(self):
784
829
        """Return the set of transform ids affected by the transform"""
785
830
        trans_ids = set(self._removed_id)
844
889
        Return a (name, parent, kind, executable) tuple
845
890
        """
846
891
        to_name = self.final_name(to_trans_id)
847
 
        try:
848
 
            to_kind = self.final_kind(to_trans_id)
849
 
        except NoSuchFile:
850
 
            to_kind = None
 
892
        to_kind = self.final_kind(to_trans_id)
851
893
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
852
894
        if to_trans_id in self._new_executability:
853
895
            to_executable = self._new_executability[to_trans_id]
927
969
        """
928
970
        return _PreviewTree(self)
929
971
 
930
 
    def commit(self, branch, message, merge_parents=None, strict=False):
 
972
    def commit(self, branch, message, merge_parents=None, strict=False,
 
973
               timestamp=None, timezone=None, committer=None, authors=None,
 
974
               revprops=None, revision_id=None):
931
975
        """Commit the result of this TreeTransform to a branch.
932
976
 
933
977
        :param branch: The branch to commit to.
934
978
        :param message: The message to attach to the commit.
935
 
        :param merge_parents: Additional parents specified by pending merges.
 
979
        :param merge_parents: Additional parent revision-ids specified by
 
980
            pending merges.
 
981
        :param strict: If True, abort the commit if there are unversioned
 
982
            files.
 
983
        :param timestamp: if not None, seconds-since-epoch for the time and
 
984
            date.  (May be a float.)
 
985
        :param timezone: Optional timezone for timestamp, as an offset in
 
986
            seconds.
 
987
        :param committer: Optional committer in email-id format.
 
988
            (e.g. "J Random Hacker <jrandom@example.com>")
 
989
        :param authors: Optional list of authors in email-id format.
 
990
        :param revprops: Optional dictionary of revision properties.
 
991
        :param revision_id: Optional revision id.  (Specifying a revision-id
 
992
            may reduce performance for some non-native formats.)
936
993
        :return: The revision_id of the revision committed.
937
994
        """
938
995
        self._check_malformed()
955
1012
        if self._tree.get_revision_id() != last_rev_id:
956
1013
            raise ValueError('TreeTransform not based on branch basis: %s' %
957
1014
                             self._tree.get_revision_id())
958
 
        builder = branch.get_commit_builder(parent_ids)
 
1015
        revprops = commit.Commit.update_revprops(revprops, branch, authors)
 
1016
        builder = branch.get_commit_builder(parent_ids,
 
1017
                                            timestamp=timestamp,
 
1018
                                            timezone=timezone,
 
1019
                                            committer=committer,
 
1020
                                            revprops=revprops,
 
1021
                                            revision_id=revision_id)
959
1022
        preview = self.get_preview_tree()
960
1023
        list(builder.record_iter_changes(preview, last_rev_id,
961
1024
                                         self.iter_changes()))
1160
1223
            if trans_id not in self._new_contents:
1161
1224
                continue
1162
1225
            new_path = self._limbo_name(trans_id)
1163
 
            osutils.rename(old_path, new_path)
 
1226
            os.rename(old_path, new_path)
1164
1227
            for descendant in self._limbo_descendants(trans_id):
1165
1228
                desc_path = self._limbo_files[descendant]
1166
1229
                desc_path = new_path + desc_path[len(old_path):]
1274
1337
            del self._limbo_children_names[trans_id]
1275
1338
        delete_any(self._limbo_name(trans_id))
1276
1339
 
 
1340
    def new_orphan(self, trans_id, parent_id):
 
1341
        # FIXME: There is no tree config, so we use the branch one (it's weird
 
1342
        # to define it this way as orphaning can only occur in a working tree,
 
1343
        # but that's all we have (for now). It will find the option in
 
1344
        # locations.conf or bazaar.conf though) -- vila 20100916
 
1345
        conf = self._tree.branch.get_config()
 
1346
        conf_var_name = 'bzr.transform.orphan_policy'
 
1347
        orphan_policy = conf.get_user_option(conf_var_name)
 
1348
        default_policy = orphaning_registry.default_key
 
1349
        if orphan_policy is None:
 
1350
            orphan_policy = default_policy
 
1351
        if orphan_policy not in orphaning_registry:
 
1352
            trace.warning('%s (from %s) is not a known policy, defaulting to %s'
 
1353
                          % (orphan_policy, conf_var_name, default_policy))
 
1354
            orphan_policy = default_policy
 
1355
        handle_orphan = orphaning_registry.get(orphan_policy)
 
1356
        handle_orphan(self, trans_id, parent_id)
 
1357
 
 
1358
 
 
1359
class OrphaningError(errors.BzrError):
 
1360
 
 
1361
    # Only bugs could lead to such exception being seen by the user
 
1362
    internal_error = True
 
1363
    _fmt = "Error while orphaning %s in %s directory"
 
1364
 
 
1365
    def __init__(self, orphan, parent):
 
1366
        errors.BzrError.__init__(self)
 
1367
        self.orphan = orphan
 
1368
        self.parent = parent
 
1369
 
 
1370
 
 
1371
class OrphaningForbidden(OrphaningError):
 
1372
 
 
1373
    _fmt = "Policy: %s doesn't allow creating orphans."
 
1374
 
 
1375
    def __init__(self, policy):
 
1376
        errors.BzrError.__init__(self)
 
1377
        self.policy = policy
 
1378
 
 
1379
 
 
1380
def move_orphan(tt, orphan_id, parent_id):
 
1381
    """See TreeTransformBase.new_orphan.
 
1382
 
 
1383
    This creates a new orphan in the `bzr-orphans` dir at the root of the
 
1384
    `TreeTransform`.
 
1385
 
 
1386
    :param tt: The TreeTransform orphaning `trans_id`.
 
1387
 
 
1388
    :param orphan_id: The trans id that should be orphaned.
 
1389
 
 
1390
    :param parent_id: The orphan parent trans id.
 
1391
    """
 
1392
    # Add the orphan dir if it doesn't exist
 
1393
    orphan_dir_basename = 'bzr-orphans'
 
1394
    od_id = tt.trans_id_tree_path(orphan_dir_basename)
 
1395
    if tt.final_kind(od_id) is None:
 
1396
        tt.create_directory(od_id)
 
1397
    parent_path = tt._tree_id_paths[parent_id]
 
1398
    # Find a name that doesn't exist yet in the orphan dir
 
1399
    actual_name = tt.final_name(orphan_id)
 
1400
    new_name = tt._available_backup_name(actual_name, od_id)
 
1401
    tt.adjust_path(new_name, od_id, orphan_id)
 
1402
    trace.warning('%s has been orphaned in %s'
 
1403
                  % (joinpath(parent_path, actual_name), orphan_dir_basename))
 
1404
 
 
1405
 
 
1406
def refuse_orphan(tt, orphan_id, parent_id):
 
1407
    """See TreeTransformBase.new_orphan.
 
1408
 
 
1409
    This refuses to create orphan, letting the caller handle the conflict.
 
1410
    """
 
1411
    raise OrphaningForbidden('never')
 
1412
 
 
1413
 
 
1414
orphaning_registry = registry.Registry()
 
1415
orphaning_registry.register(
 
1416
    'conflict', refuse_orphan,
 
1417
    'Leave orphans in place and create a conflict on the directory.')
 
1418
orphaning_registry.register(
 
1419
    'move', move_orphan,
 
1420
    'Move orphans into the bzr-orphans directory.')
 
1421
orphaning_registry._set_default_key('conflict')
 
1422
 
1277
1423
 
1278
1424
class TreeTransform(DiskTreeTransform):
1279
1425
    """Represent a tree transformation.
1397
1543
    def tree_kind(self, trans_id):
1398
1544
        """Determine the file kind in the working tree.
1399
1545
 
1400
 
        Raises NoSuchFile if the file does not exist
 
1546
        :returns: The file kind or None if the file does not exist
1401
1547
        """
1402
1548
        path = self._tree_id_paths.get(trans_id)
1403
1549
        if path is None:
1404
 
            raise NoSuchFile(None)
 
1550
            return None
1405
1551
        try:
1406
1552
            return file_kind(self._tree.abspath(path))
1407
 
        except OSError, e:
1408
 
            if e.errno != errno.ENOENT:
1409
 
                raise
1410
 
            else:
1411
 
                raise NoSuchFile(path)
 
1553
        except errors.NoSuchFile:
 
1554
            return None
1412
1555
 
1413
1556
    def _set_mode(self, trans_id, mode_id, typefunc):
1414
1557
        """Set the mode of new file contents.
1583
1726
                if file_id is None:
1584
1727
                    continue
1585
1728
                needs_entry = False
1586
 
                try:
1587
 
                    kind = self.final_kind(trans_id)
1588
 
                except NoSuchFile:
 
1729
                kind = self.final_kind(trans_id)
 
1730
                if kind is None:
1589
1731
                    kind = self._tree.stored_kind(file_id)
1590
1732
                parent_trans_id = self.final_parent(trans_id)
1591
1733
                parent_file_id = new_path_file_ids.get(parent_trans_id)
1635
1777
                      or trans_id in self._new_parent):
1636
1778
                    try:
1637
1779
                        mover.rename(full_path, self._limbo_name(trans_id))
1638
 
                    except OSError, e:
 
1780
                    except errors.TransformRenameFailed, e:
1639
1781
                        if e.errno != errno.ENOENT:
1640
1782
                            raise
1641
1783
                    else:
1666
1808
                if trans_id in self._needs_rename:
1667
1809
                    try:
1668
1810
                        mover.rename(self._limbo_name(trans_id), full_path)
1669
 
                    except OSError, e:
 
1811
                    except errors.TransformRenameFailed, e:
1670
1812
                        # We may be renaming a dangling inventory id
1671
1813
                        if e.errno != errno.ENOENT:
1672
1814
                            raise
1703
1845
    def tree_kind(self, trans_id):
1704
1846
        path = self._tree_id_paths.get(trans_id)
1705
1847
        if path is None:
1706
 
            raise NoSuchFile(None)
 
1848
            return None
1707
1849
        file_id = self._tree.path2id(path)
1708
 
        return self._tree.kind(file_id)
 
1850
        try:
 
1851
            return self._tree.kind(file_id)
 
1852
        except errors.NoSuchFile:
 
1853
            return None
1709
1854
 
1710
1855
    def _set_mode(self, trans_id, mode_id, typefunc):
1711
1856
        """Set the mode of new file contents.
1731
1876
            childpath = joinpath(path, child)
1732
1877
            yield self.trans_id_tree_path(childpath)
1733
1878
 
 
1879
    def new_orphan(self, trans_id, parent_id):
 
1880
        raise NotImplementedError(self.new_orphan)
 
1881
 
1734
1882
 
1735
1883
class _PreviewTree(tree.Tree):
1736
1884
    """Partial implementation of Tree to support show_diff_trees"""
1770
1918
        parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
1771
1919
                       self._iter_parent_trees()]
1772
1920
        vf.add_lines((file_id, tree_revision), parent_keys,
1773
 
                     self.get_file(file_id).readlines())
 
1921
                     self.get_file_lines(file_id))
1774
1922
        repo = self._get_repository()
1775
1923
        base_vf = repo.texts
1776
1924
        if base_vf not in vf.fallback_versionedfiles:
1798
1946
            executable = self.is_executable(file_id, path)
1799
1947
        return kind, executable, None
1800
1948
 
 
1949
    def is_locked(self):
 
1950
        return False
 
1951
 
1801
1952
    def lock_read(self):
1802
1953
        # Perhaps in theory, this should lock the TreeTransform?
1803
 
        pass
 
1954
        return self
1804
1955
 
1805
1956
    def unlock(self):
1806
1957
        pass
1904
2055
            if (specific_file_ids is not None
1905
2056
                and file_id not in specific_file_ids):
1906
2057
                continue
1907
 
            try:
1908
 
                kind = self._transform.final_kind(trans_id)
1909
 
            except NoSuchFile:
 
2058
            kind = self._transform.final_kind(trans_id)
 
2059
            if kind is None:
1910
2060
                kind = self._transform._tree.stored_kind(file_id)
1911
2061
            new_entry = inventory.make_entry(
1912
2062
                kind,
2144
2294
                path_from_root = self._final_paths.get_path(child_id)
2145
2295
                basename = self._transform.final_name(child_id)
2146
2296
                file_id = self._transform.final_file_id(child_id)
2147
 
                try:
2148
 
                    kind = self._transform.final_kind(child_id)
 
2297
                kind  = self._transform.final_kind(child_id)
 
2298
                if kind is not None:
2149
2299
                    versioned_kind = kind
2150
 
                except NoSuchFile:
 
2300
                else:
2151
2301
                    kind = 'unknown'
2152
2302
                    versioned_kind = self._transform._tree.stored_kind(file_id)
2153
2303
                if versioned_kind == 'directory':
2266
2416
    for num, _unused in enumerate(wt.all_file_ids()):
2267
2417
        if num > 0:  # more than just a root
2268
2418
            raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
2269
 
    existing_files = set()
2270
 
    for dir, files in wt.walkdirs():
2271
 
        existing_files.update(f[0] for f in files)
2272
2419
    file_trans_id = {}
2273
2420
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2274
2421
    pp = ProgressPhase("Build phase", 2, top_pb)
2298
2445
                precomputed_delta = []
2299
2446
            else:
2300
2447
                precomputed_delta = None
 
2448
            # Check if tree inventory has content. If so, we populate
 
2449
            # existing_files with the directory content. If there are no
 
2450
            # entries we skip populating existing_files as its not used.
 
2451
            # This improves performance and unncessary work on large
 
2452
            # directory trees. (#501307)
 
2453
            if total > 0:
 
2454
                existing_files = set()
 
2455
                for dir, files in wt.walkdirs():
 
2456
                    existing_files.update(f[0] for f in files)
2301
2457
            for num, (tree_path, entry) in \
2302
2458
                enumerate(tree.inventory.iter_entries_by_dir()):
2303
2459
                pb.update("Building tree", num - len(deferred_contents), total)
2423
2579
    for child in tt.iter_tree_children(old_parent):
2424
2580
        tt.adjust_path(tt.final_name(child), new_parent, child)
2425
2581
 
 
2582
 
2426
2583
def _reparent_transform_children(tt, old_parent, new_parent):
2427
2584
    by_parent = tt.by_parent()
2428
2585
    for child in by_parent[old_parent]:
2429
2586
        tt.adjust_path(tt.final_name(child), new_parent, child)
2430
2587
    return by_parent[old_parent]
2431
2588
 
 
2589
 
2432
2590
def _content_match(tree, entry, file_id, kind, target_path):
2433
2591
    if entry.kind != kind:
2434
2592
        return False
2435
2593
    if entry.kind == "directory":
2436
2594
        return True
2437
2595
    if entry.kind == "file":
2438
 
        if tree.get_file(file_id).read() == file(target_path, 'rb').read():
2439
 
            return True
 
2596
        f = file(target_path, 'rb')
 
2597
        try:
 
2598
            if tree.get_file_text(file_id) == f.read():
 
2599
                return True
 
2600
        finally:
 
2601
            f.close()
2440
2602
    elif entry.kind == "symlink":
2441
2603
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
2442
2604
            return True
2494
2656
        raise errors.BadFileKindError(name, kind)
2495
2657
 
2496
2658
 
2497
 
@deprecated_function(deprecated_in((1, 9, 0)))
2498
 
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
2499
 
    """Create new file contents according to an inventory entry.
2500
 
 
2501
 
    DEPRECATED.  Use create_from_tree instead.
2502
 
    """
2503
 
    if entry.kind == "file":
2504
 
        if lines is None:
2505
 
            lines = tree.get_file(entry.file_id).readlines()
2506
 
        tt.create_file(lines, trans_id, mode_id=mode_id)
2507
 
    elif entry.kind == "symlink":
2508
 
        tt.create_symlink(tree.get_symlink_target(entry.file_id), trans_id)
2509
 
    elif entry.kind == "directory":
2510
 
        tt.create_directory(trans_id)
2511
 
 
2512
 
 
2513
2659
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2514
2660
    filter_tree_path=None):
2515
2661
    """Create new file contents according to tree contents.
2546
2692
        tt.set_executability(entry.executable, trans_id)
2547
2693
 
2548
2694
 
 
2695
@deprecated_function(deprecated_in((2, 3, 0)))
2549
2696
def get_backup_name(entry, by_parent, parent_trans_id, tt):
2550
2697
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
2551
2698
 
2552
2699
 
 
2700
@deprecated_function(deprecated_in((2, 3, 0)))
2553
2701
def _get_backup_name(name, by_parent, parent_trans_id, tt):
2554
2702
    """Produce a backup-style name that appears to be available"""
2555
2703
    def name_gen():
2676
2824
                        tt.delete_contents(trans_id)
2677
2825
                    elif kind[1] is not None:
2678
2826
                        parent_trans_id = tt.trans_id_file_id(parent[0])
2679
 
                        by_parent = tt.by_parent()
2680
 
                        backup_name = _get_backup_name(name[0], by_parent,
2681
 
                                                       parent_trans_id, tt)
 
2827
                        backup_name = tt._available_backup_name(
 
2828
                            name[0], parent_trans_id)
2682
2829
                        tt.adjust_path(backup_name, parent_trans_id, trans_id)
2683
2830
                        new_trans_id = tt.create_path(name[0], parent_trans_id)
2684
2831
                        if versioned == (True, True):
2807
2954
 
2808
2955
        elif c_type == 'missing parent':
2809
2956
            trans_id = conflict[1]
2810
 
            try:
2811
 
                tt.cancel_deletion(trans_id)
2812
 
                new_conflicts.add(('deleting parent', 'Not deleting',
2813
 
                                   trans_id))
2814
 
            except KeyError:
 
2957
            if trans_id in tt._removed_contents:
 
2958
                cancel_deletion = True
 
2959
                orphans = tt._get_potential_orphans(trans_id)
 
2960
                if orphans:
 
2961
                    cancel_deletion = False
 
2962
                    # All children are orphans
 
2963
                    for o in orphans:
 
2964
                        try:
 
2965
                            tt.new_orphan(o, trans_id)
 
2966
                        except OrphaningError:
 
2967
                            # Something bad happened so we cancel the directory
 
2968
                            # deletion which will leave it in place with a
 
2969
                            # conflict. The user can deal with it from there.
 
2970
                            # Note that this also catch the case where we don't
 
2971
                            # want to create orphans and leave the directory in
 
2972
                            # place.
 
2973
                            cancel_deletion = True
 
2974
                            break
 
2975
                if cancel_deletion:
 
2976
                    # Cancel the directory deletion
 
2977
                    tt.cancel_deletion(trans_id)
 
2978
                    new_conflicts.add(('deleting parent', 'Not deleting',
 
2979
                                       trans_id))
 
2980
            else:
2815
2981
                create = True
2816
2982
                try:
2817
2983
                    tt.final_name(trans_id)
2900
3066
    def rename(self, from_, to):
2901
3067
        """Rename a file from one path to another."""
2902
3068
        try:
2903
 
            osutils.rename(from_, to)
 
3069
            os.rename(from_, to)
2904
3070
        except OSError, e:
2905
3071
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
2906
3072
                raise errors.FileExists(to, str(e))
2907
 
            raise
 
3073
            # normal OSError doesn't include filenames so it's hard to see where
 
3074
            # the problem is, see https://bugs.launchpad.net/bzr/+bug/491763
 
3075
            raise errors.TransformRenameFailed(from_, to, str(e), e.errno)
2908
3076
        self.past_renames.append((from_, to))
2909
3077
 
2910
3078
    def pre_delete(self, from_, to):
2920
3088
    def rollback(self):
2921
3089
        """Reverse all renames that have been performed"""
2922
3090
        for from_, to in reversed(self.past_renames):
2923
 
            osutils.rename(to, from_)
 
3091
            try:
 
3092
                os.rename(to, from_)
 
3093
            except OSError, e:
 
3094
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
2924
3095
        # after rollback, don't reuse _FileMover
2925
3096
        past_renames = None
2926
3097
        pending_deletions = None