← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: Patch Queue Manager
  • Date: 2016-04-21 04:10:52 UTC
  • mfrom: (6616.1.1 fix-en-user-guide)
  • Revision ID: pqm@pqm.ubuntu.com-20160421041052-clcye7ns1qcl2n7w
(richard-wilbur) Ensure build of English use guide always uses English text
 even when user's locale specifies a different language. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transform.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
from __future__ import absolute_import
 
18
 
17
19
import os
18
20
import errno
19
21
from stat import S_ISREG, S_IEXEC
20
22
import time
21
23
 
22
24
from bzrlib import (
 
25
    config as _mod_config,
23
26
    errors,
24
27
    lazy_import,
25
28
    registry,
30
33
from bzrlib import (
31
34
    annotate,
32
35
    bencode,
33
 
    bzrdir,
 
36
    controldir,
34
37
    commit,
 
38
    conflicts,
35
39
    delta,
36
 
    errors,
37
40
    inventory,
38
41
    multiparent,
39
42
    osutils,
41
44
    ui,
42
45
    urlutils,
43
46
    )
 
47
from bzrlib.i18n import gettext
44
48
""")
45
 
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
 
49
from bzrlib.errors import (DuplicateKey, MalformedTransform,
46
50
                           ReusingTransform, CantMoveRoot,
47
 
                           ExistingLimbo, ImmortalLimbo, NoFinalPath,
 
51
                           ImmortalLimbo, NoFinalPath,
48
52
                           UnableCreateSymlink)
49
53
from bzrlib.filters import filtered_output_bytes, ContentFilterContext
 
54
from bzrlib.mutabletree import MutableTree
50
55
from bzrlib.osutils import (
51
56
    delete_any,
52
57
    file_kind,
54
59
    pathjoin,
55
60
    sha_file,
56
61
    splitpath,
57
 
    supports_executable,
58
62
    )
59
63
from bzrlib.progress import ProgressPhase
60
64
from bzrlib.symbol_versioning import (
137
141
        # A counter of how many files have been renamed
138
142
        self.rename_count = 0
139
143
 
 
144
    def __enter__(self):
 
145
        """Support Context Manager API."""
 
146
        return self
 
147
 
 
148
    def __exit__(self, exc_type, exc_val, exc_tb):
 
149
        """Support Context Manager API."""
 
150
        self.finalize()
 
151
 
140
152
    def finalize(self):
141
153
        """Release the working tree lock, if held.
142
154
 
145
157
        """
146
158
        if self._tree is None:
147
159
            return
 
160
        for hook in MutableTree.hooks['post_transform']:
 
161
            hook(self._tree, self)
148
162
        self._tree.unlock()
149
163
        self._tree = None
150
164
 
217
231
        This means that the old root trans-id becomes obsolete, so it is
218
232
        recommended only to invoke this after the root trans-id has become
219
233
        irrelevant.
 
234
 
220
235
        """
221
 
        new_roots = [k for k, v in self._new_parent.iteritems() if v is
 
236
        new_roots = [k for k, v in self._new_parent.iteritems() if v ==
222
237
                     ROOT_PARENT]
223
238
        if len(new_roots) < 1:
224
239
            return
228
243
            self._new_root = new_roots[0]
229
244
            return
230
245
        old_new_root = new_roots[0]
231
 
        # TODO: What to do if a old_new_root is present, but self._new_root is
232
 
        #       not listed as being removed? This code explicitly unversions
233
 
        #       the old root and versions it with the new file_id. Though that
234
 
        #       seems like an incomplete delta
235
 
 
236
246
        # unversion the new root's directory.
237
 
        file_id = self.final_file_id(old_new_root)
 
247
        if self.final_kind(self._new_root) is None:
 
248
            file_id = self.final_file_id(old_new_root)
 
249
        else:
 
250
            file_id = self.final_file_id(self._new_root)
238
251
        if old_new_root in self._new_id:
239
252
            self.cancel_versioning(old_new_root)
240
253
        else:
244
257
        if (self.tree_file_id(self._new_root) is not None and
245
258
            self._new_root not in self._removed_id):
246
259
            self.unversion_file(self._new_root)
247
 
        self.version_file(file_id, self._new_root)
 
260
        if file_id is not None:
 
261
            self.version_file(file_id, self._new_root)
248
262
 
249
263
        # Now move children of new root into old root directory.
250
264
        # Ensure all children are registered with the transaction, but don't
384
398
        return sorted(FinalPaths(self).get_paths(new_ids))
385
399
 
386
400
    def _inventory_altered(self):
387
 
        """Get the trans_ids and paths of files needing new inv entries."""
388
 
        new_ids = set()
389
 
        for id_set in [self._new_name, self._new_parent, self._new_id,
 
401
        """Determine which trans_ids need new Inventory entries.
 
402
 
 
403
        An new entry is needed when anything that would be reflected by an
 
404
        inventory entry changes, including file name, file_id, parent file_id,
 
405
        file kind, and the execute bit.
 
406
 
 
407
        Some care is taken to return entries with real changes, not cases
 
408
        where the value is deleted and then restored to its original value,
 
409
        but some actually unchanged values may be returned.
 
410
 
 
411
        :returns: A list of (path, trans_id) for all items requiring an
 
412
            inventory change. Ordered by path.
 
413
        """
 
414
        changed_ids = set()
 
415
        # Find entries whose file_ids are new (or changed).
 
416
        new_file_id = set(t for t in self._new_id
 
417
                          if self._new_id[t] != self.tree_file_id(t))
 
418
        for id_set in [self._new_name, self._new_parent, new_file_id,
390
419
                       self._new_executability]:
391
 
            new_ids.update(id_set)
 
420
            changed_ids.update(id_set)
 
421
        # removing implies a kind change
392
422
        changed_kind = set(self._removed_contents)
 
423
        # so does adding
393
424
        changed_kind.intersection_update(self._new_contents)
394
 
        changed_kind.difference_update(new_ids)
 
425
        # Ignore entries that are already known to have changed.
 
426
        changed_kind.difference_update(changed_ids)
 
427
        #  to keep only the truly changed ones
395
428
        changed_kind = (t for t in changed_kind
396
429
                        if self.tree_kind(t) != self.final_kind(t))
397
 
        new_ids.update(changed_kind)
398
 
        return sorted(FinalPaths(self).get_paths(new_ids))
 
430
        # all kind changes will alter the inventory
 
431
        changed_ids.update(changed_kind)
 
432
        # To find entries with changed parent_ids, find parents which existed,
 
433
        # but changed file_id.
 
434
        changed_file_id = set(t for t in new_file_id if t in self._removed_id)
 
435
        # Now add all their children to the set.
 
436
        for parent_trans_id in new_file_id:
 
437
            changed_ids.update(self.iter_tree_children(parent_trans_id))
 
438
        return sorted(FinalPaths(self).get_paths(changed_ids))
399
439
 
400
440
    def final_kind(self, trans_id):
401
441
        """Determine the final file kind, after any changes applied.
526
566
        for trans_id in self._removed_id:
527
567
            file_id = self.tree_file_id(trans_id)
528
568
            if file_id is not None:
529
 
                # XXX: This seems like something that should go via a different
530
 
                #      indirection.
531
 
                if self._tree.inventory[file_id].kind == 'directory':
 
569
                if self._tree.stored_kind(file_id) == 'directory':
532
570
                    parents.append(trans_id)
533
571
            elif self.tree_kind(trans_id) == 'directory':
534
572
                parents.append(trans_id)
537
575
            # ensure that all children are registered with the transaction
538
576
            list(self.iter_tree_children(parent_id))
539
577
 
540
 
    @deprecated_method(deprecated_in((2, 3, 0)))
541
 
    def has_named_child(self, by_parent, parent_id, name):
542
 
        return self._has_named_child(
543
 
            name, parent_id, known_children=by_parent.get(parent_id, []))
544
 
 
545
578
    def _has_named_child(self, name, parent_id, known_children):
546
579
        """Does a parent already have a name child.
547
580
 
591
624
        for trans_id in self._new_parent:
592
625
            seen = set()
593
626
            parent_id = trans_id
594
 
            while parent_id is not ROOT_PARENT:
 
627
            while parent_id != ROOT_PARENT:
595
628
                seen.add(parent_id)
596
629
                try:
597
630
                    parent_id = self.final_parent(parent_id)
607
640
        """If parent directories are versioned, children must be versioned."""
608
641
        conflicts = []
609
642
        for parent_id, children in by_parent.iteritems():
610
 
            if parent_id is ROOT_PARENT:
 
643
            if parent_id == ROOT_PARENT:
611
644
                continue
612
645
            if self.final_file_id(parent_id) is not None:
613
646
                continue
706
739
        """Children must have a directory parent"""
707
740
        conflicts = []
708
741
        for parent_id, children in by_parent.iteritems():
709
 
            if parent_id is ROOT_PARENT:
 
742
            if parent_id == ROOT_PARENT:
710
743
                continue
711
744
            no_children = True
712
745
            for child_id in children:
728
761
 
729
762
    def _set_executability(self, path, trans_id):
730
763
        """Set the executability of versioned files """
731
 
        if supports_executable():
 
764
        if self._tree._supports_executable():
732
765
            new_executability = self._new_executability[trans_id]
733
766
            abspath = self._tree.abspath(path)
734
767
            current_mode = os.stat(abspath).st_mode
743
776
                    to_mode |= 0010 & ~umask
744
777
            else:
745
778
                to_mode = current_mode & ~0111
746
 
            os.chmod(abspath, to_mode)
 
779
            osutils.chmod_if_possible(abspath, to_mode)
747
780
 
748
781
    def _new_entry(self, name, parent_id, file_id):
749
782
        """Helper function to create a new filesystem entry."""
1154
1187
        self._deletiondir = None
1155
1188
        # A mapping of transform ids to their limbo filename
1156
1189
        self._limbo_files = {}
 
1190
        self._possibly_stale_limbo_files = set()
1157
1191
        # A mapping of transform ids to a set of the transform ids of children
1158
1192
        # that their limbo directory has
1159
1193
        self._limbo_children = {}
1172
1206
        if self._tree is None:
1173
1207
            return
1174
1208
        try:
1175
 
            entries = [(self._limbo_name(t), t, k) for t, k in
1176
 
                       self._new_contents.iteritems()]
1177
 
            entries.sort(reverse=True)
1178
 
            for path, trans_id, kind in entries:
1179
 
                delete_any(path)
 
1209
            limbo_paths = self._limbo_files.values() + list(
 
1210
                self._possibly_stale_limbo_files)
 
1211
            limbo_paths = sorted(limbo_paths, reverse=True)
 
1212
            for path in limbo_paths:
 
1213
                try:
 
1214
                    delete_any(path)
 
1215
                except OSError, e:
 
1216
                    if e.errno != errno.ENOENT:
 
1217
                        raise
 
1218
                    # XXX: warn? perhaps we just got interrupted at an
 
1219
                    # inconvenient moment, but perhaps files are disappearing
 
1220
                    # from under us?
1180
1221
            try:
1181
1222
                delete_any(self._limbodir)
1182
1223
            except OSError:
1190
1231
        finally:
1191
1232
            TreeTransformBase.finalize(self)
1192
1233
 
 
1234
    def _limbo_supports_executable(self):
 
1235
        """Check if the limbo path supports the executable bit."""
 
1236
        # FIXME: Check actual file system capabilities of limbodir
 
1237
        return osutils.supports_executable()
 
1238
 
1193
1239
    def _limbo_name(self, trans_id):
1194
1240
        """Generate the limbo name of a file"""
1195
1241
        limbo_name = self._limbo_files.get(trans_id)
1231
1277
        entries from _limbo_files, because they are now stale.
1232
1278
        """
1233
1279
        for trans_id in trans_ids:
1234
 
            old_path = self._limbo_files.pop(trans_id)
 
1280
            old_path = self._limbo_files[trans_id]
 
1281
            self._possibly_stale_limbo_files.add(old_path)
 
1282
            del self._limbo_files[trans_id]
1235
1283
            if trans_id not in self._new_contents:
1236
1284
                continue
1237
1285
            new_path = self._limbo_name(trans_id)
1238
1286
            os.rename(old_path, new_path)
 
1287
            self._possibly_stale_limbo_files.remove(old_path)
1239
1288
            for descendant in self._limbo_descendants(trans_id):
1240
1289
                desc_path = self._limbo_files[descendant]
1241
1290
                desc_path = new_path + desc_path[len(old_path):]
1265
1314
        name = self._limbo_name(trans_id)
1266
1315
        f = open(name, 'wb')
1267
1316
        try:
1268
 
            try:
1269
 
                unique_add(self._new_contents, trans_id, 'file')
1270
 
            except:
1271
 
                # Clean up the file, it never got registered so
1272
 
                # TreeTransform.finalize() won't clean it up.
1273
 
                f.close()
1274
 
                os.unlink(name)
1275
 
                raise
 
1317
            unique_add(self._new_contents, trans_id, 'file')
1276
1318
            f.writelines(contents)
1277
1319
        finally:
1278
1320
            f.close()
1359
1401
        delete_any(self._limbo_name(trans_id))
1360
1402
 
1361
1403
    def new_orphan(self, trans_id, parent_id):
1362
 
        # FIXME: There is no tree config, so we use the branch one (it's weird
1363
 
        # to define it this way as orphaning can only occur in a working tree,
1364
 
        # but that's all we have (for now). It will find the option in
1365
 
        # locations.conf or bazaar.conf though) -- vila 20100916
1366
 
        conf = self._tree.branch.get_config()
1367
 
        conf_var_name = 'bzr.transform.orphan_policy'
1368
 
        orphan_policy = conf.get_user_option(conf_var_name)
1369
 
        default_policy = orphaning_registry.default_key
1370
 
        if orphan_policy is None:
1371
 
            orphan_policy = default_policy
1372
 
        if orphan_policy not in orphaning_registry:
1373
 
            trace.warning('%s (from %s) is not a known policy, defaulting '
1374
 
                'to %s' % (orphan_policy, conf_var_name, default_policy))
1375
 
            orphan_policy = default_policy
1376
 
        handle_orphan = orphaning_registry.get(orphan_policy)
 
1404
        conf = self._tree.get_config_stack()
 
1405
        handle_orphan = conf.get('bzr.transform.orphan_policy')
1377
1406
        handle_orphan(self, trans_id, parent_id)
1378
1407
 
1379
1408
 
1442
1471
orphaning_registry._set_default_key('conflict')
1443
1472
 
1444
1473
 
 
1474
opt_transform_orphan = _mod_config.RegistryOption(
 
1475
    'bzr.transform.orphan_policy', orphaning_registry,
 
1476
    help='Policy for orphaned files during transform operations.',
 
1477
    invalid='warning')
 
1478
 
 
1479
 
1445
1480
class TreeTransform(DiskTreeTransform):
1446
1481
    """Represent a tree transformation.
1447
1482
 
1518
1553
        try:
1519
1554
            limbodir = urlutils.local_path_from_url(
1520
1555
                tree._transport.abspath('limbo'))
1521
 
            try:
1522
 
                os.mkdir(limbodir)
1523
 
            except OSError, e:
1524
 
                if e.errno == errno.EEXIST:
1525
 
                    raise ExistingLimbo(limbodir)
 
1556
            osutils.ensure_empty_directory_exists(
 
1557
                limbodir,
 
1558
                errors.ExistingLimbo)
1526
1559
            deletiondir = urlutils.local_path_from_url(
1527
1560
                tree._transport.abspath('pending-deletion'))
1528
 
            try:
1529
 
                os.mkdir(deletiondir)
1530
 
            except OSError, e:
1531
 
                if e.errno == errno.EEXIST:
1532
 
                    raise errors.ExistingPendingDeletion(deletiondir)
 
1561
            osutils.ensure_empty_directory_exists(
 
1562
                deletiondir,
 
1563
                errors.ExistingPendingDeletion)
1533
1564
        except:
1534
1565
            tree.unlock()
1535
1566
            raise
1598
1629
            else:
1599
1630
                raise
1600
1631
        if typefunc(mode):
1601
 
            os.chmod(self._limbo_name(trans_id), mode)
 
1632
            osutils.chmod_if_possible(self._limbo_name(trans_id), mode)
1602
1633
 
1603
1634
    def iter_tree_children(self, parent_id):
1604
1635
        """Iterate through the entry's tree children, if any"""
1682
1713
            calculating one.
1683
1714
        :param _mover: Supply an alternate FileMover, for testing
1684
1715
        """
 
1716
        for hook in MutableTree.hooks['pre_transform']:
 
1717
            hook(self._tree, self)
1685
1718
        if not no_conflicts:
1686
1719
            self._check_malformed()
1687
1720
        child_pb = ui.ui_factory.nested_progress_bar()
1688
1721
        try:
1689
1722
            if precomputed_delta is None:
1690
 
                child_pb.update('Apply phase', 0, 2)
 
1723
                child_pb.update(gettext('Apply phase'), 0, 2)
1691
1724
                inventory_delta = self._generate_inventory_delta()
1692
1725
                offset = 1
1693
1726
            else:
1698
1731
            else:
1699
1732
                mover = _mover
1700
1733
            try:
1701
 
                child_pb.update('Apply phase', 0 + offset, 2 + offset)
 
1734
                child_pb.update(gettext('Apply phase'), 0 + offset, 2 + offset)
1702
1735
                self._apply_removals(mover)
1703
 
                child_pb.update('Apply phase', 1 + offset, 2 + offset)
 
1736
                child_pb.update(gettext('Apply phase'), 1 + offset, 2 + offset)
1704
1737
                modified_paths = self._apply_insertions(mover)
1705
1738
            except:
1706
1739
                mover.rollback()
1709
1742
                mover.apply_deletions()
1710
1743
        finally:
1711
1744
            child_pb.finished()
 
1745
        if self.final_file_id(self.root) is None:
 
1746
            inventory_delta = [e for e in inventory_delta if e[0] != '']
1712
1747
        self._tree.apply_inventory_delta(inventory_delta)
1713
1748
        self._apply_observed_sha1s()
1714
1749
        self._done = True
1724
1759
        try:
1725
1760
            for num, trans_id in enumerate(self._removed_id):
1726
1761
                if (num % 10) == 0:
1727
 
                    child_pb.update('removing file', num, total_entries)
 
1762
                    child_pb.update(gettext('removing file'), num, total_entries)
1728
1763
                if trans_id == self._new_root:
1729
1764
                    file_id = self._tree.get_root_id()
1730
1765
                else:
1742
1777
            final_kinds = {}
1743
1778
            for num, (path, trans_id) in enumerate(new_paths):
1744
1779
                if (num % 10) == 0:
1745
 
                    child_pb.update('adding file',
 
1780
                    child_pb.update(gettext('adding file'),
1746
1781
                                    num + len(self._removed_id), total_entries)
1747
1782
                file_id = new_path_file_ids[trans_id]
1748
1783
                if file_id is None:
1788
1823
        tree_paths.sort(reverse=True)
1789
1824
        child_pb = ui.ui_factory.nested_progress_bar()
1790
1825
        try:
1791
 
            for num, data in enumerate(tree_paths):
1792
 
                path, trans_id = data
1793
 
                child_pb.update('removing file', num, len(tree_paths))
 
1826
            for num, (path, trans_id) in enumerate(tree_paths):
 
1827
                # do not attempt to move root into a subdirectory of itself.
 
1828
                if path == '':
 
1829
                    continue
 
1830
                child_pb.update(gettext('removing file'), num, len(tree_paths))
1794
1831
                full_path = self._tree.abspath(path)
1795
1832
                if trans_id in self._removed_contents:
1796
1833
                    delete_path = os.path.join(self._deletiondir, trans_id)
1825
1862
        try:
1826
1863
            for num, (path, trans_id) in enumerate(new_paths):
1827
1864
                if (num % 10) == 0:
1828
 
                    child_pb.update('adding file', num, len(new_paths))
 
1865
                    child_pb.update(gettext('adding file'), num, len(new_paths))
1829
1866
                full_path = self._tree.abspath(path)
1830
1867
                if trans_id in self._needs_rename:
1831
1868
                    try:
1851
1888
                    self._observed_sha1s[trans_id] = (o_sha1, st)
1852
1889
        finally:
1853
1890
            child_pb.finished()
 
1891
        for path, trans_id in new_paths:
 
1892
            # new_paths includes stuff like workingtree conflicts. Only the
 
1893
            # stuff in new_contents actually comes from limbo.
 
1894
            if trans_id in self._limbo_files:
 
1895
                del self._limbo_files[trans_id]
1854
1896
        self._new_contents.clear()
1855
1897
        return modified_paths
1856
1898
 
1898
1940
        path = self._tree_id_paths.get(trans_id)
1899
1941
        if path is None:
1900
1942
            return None
1901
 
        file_id = self._tree.path2id(path)
1902
 
        try:
1903
 
            return self._tree.kind(file_id)
1904
 
        except errors.NoSuchFile:
1905
 
            return None
 
1943
        kind = self._tree.path_content_summary(path)[0]
 
1944
        if kind == 'missing':
 
1945
            kind = None
 
1946
        return kind
1906
1947
 
1907
1948
    def _set_mode(self, trans_id, mode_id, typefunc):
1908
1949
        """Set the mode of new file contents.
1977
2018
            vf.fallback_versionedfiles.append(base_vf)
1978
2019
        return tree_revision
1979
2020
 
1980
 
    def _stat_limbo_file(self, file_id):
1981
 
        trans_id = self._transform.trans_id_file_id(file_id)
 
2021
    def _stat_limbo_file(self, file_id=None, trans_id=None):
 
2022
        if trans_id is None:
 
2023
            trans_id = self._transform.trans_id_file_id(file_id)
1982
2024
        name = self._transform._limbo_name(trans_id)
1983
2025
        return os.lstat(name)
1984
2026
 
2009
2051
        pass
2010
2052
 
2011
2053
    @property
 
2054
    @deprecated_method(deprecated_in((2, 5, 0)))
2012
2055
    def inventory(self):
2013
2056
        """This Tree does not use inventory as its backing data."""
2014
2057
        raise NotImplementedError(_PreviewTree.inventory)
2015
2058
 
 
2059
    @property
 
2060
    def root_inventory(self):
 
2061
        """This Tree does not use inventory as its backing data."""
 
2062
        raise NotImplementedError(_PreviewTree.root_inventory)
 
2063
 
2016
2064
    def get_root_id(self):
2017
2065
        return self._transform.final_file_id(self._transform.root)
2018
2066
 
2064
2112
        return cur_parent
2065
2113
 
2066
2114
    def path2id(self, path):
 
2115
        if isinstance(path, list):
 
2116
            if path == []:
 
2117
                path = [""]
 
2118
            path = osutils.pathjoin(*path)
2067
2119
        return self._transform.final_file_id(self._path2trans_id(path))
2068
2120
 
2069
2121
    def id2path(self, file_id):
2130
2182
                ordered_ids.append((trans_id, parent_file_id))
2131
2183
        return ordered_ids
2132
2184
 
 
2185
    def iter_child_entries(self, file_id, path=None):
 
2186
        self.id2path(file_id)
 
2187
        trans_id = self._transform.trans_id_file_id(file_id)
 
2188
        todo = [(child_trans_id, trans_id) for child_trans_id in
 
2189
                self._all_children(trans_id)]
 
2190
        for entry, trans_id in self._make_inv_entries(todo):
 
2191
            yield entry
 
2192
 
2133
2193
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
2134
2194
        # This may not be a maximally efficient implementation, but it is
2135
2195
        # reasonably straightforward.  An implementation that grafts the
2199
2259
 
2200
2260
    def get_file_size(self, file_id):
2201
2261
        """See Tree.get_file_size"""
 
2262
        trans_id = self._transform.trans_id_file_id(file_id)
 
2263
        kind = self._transform.final_kind(trans_id)
 
2264
        if kind != 'file':
 
2265
            return None
 
2266
        if trans_id in self._transform._new_contents:
 
2267
            return self._stat_limbo_file(trans_id=trans_id).st_size
2202
2268
        if self.kind(file_id) == 'file':
2203
2269
            return self._transform._tree.get_file_size(file_id)
2204
2270
        else:
2205
2271
            return None
2206
2272
 
 
2273
    def get_file_verifier(self, file_id, path=None, stat_value=None):
 
2274
        trans_id = self._transform.trans_id_file_id(file_id)
 
2275
        kind = self._transform._new_contents.get(trans_id)
 
2276
        if kind is None:
 
2277
            return self._transform._tree.get_file_verifier(file_id)
 
2278
        if kind == 'file':
 
2279
            fileobj = self.get_file(file_id)
 
2280
            try:
 
2281
                return ("SHA1", sha_file(fileobj))
 
2282
            finally:
 
2283
                fileobj.close()
 
2284
 
2207
2285
    def get_file_sha1(self, file_id, path=None, stat_value=None):
2208
2286
        trans_id = self._transform.trans_id_file_id(file_id)
2209
2287
        kind = self._transform._new_contents.get(trans_id)
2232
2310
            except errors.NoSuchId:
2233
2311
                return False
2234
2312
 
 
2313
    def has_filename(self, path):
 
2314
        trans_id = self._path2trans_id(path)
 
2315
        if trans_id in self._transform._new_contents:
 
2316
            return True
 
2317
        elif trans_id in self._transform._removed_contents:
 
2318
            return False
 
2319
        else:
 
2320
            return self._transform._tree.has_filename(path)
 
2321
 
2235
2322
    def path_content_summary(self, path):
2236
2323
        trans_id = self._path2trans_id(path)
2237
2324
        tt = self._transform
2250
2337
            if kind == 'file':
2251
2338
                statval = os.lstat(limbo_name)
2252
2339
                size = statval.st_size
2253
 
                if not supports_executable():
 
2340
                if not tt._limbo_supports_executable():
2254
2341
                    executable = False
2255
2342
                else:
2256
2343
                    executable = statval.st_mode & S_IEXEC
2325
2412
                                   self.get_file(file_id).readlines(),
2326
2413
                                   default_revision)
2327
2414
 
2328
 
    def get_symlink_target(self, file_id):
 
2415
    def get_symlink_target(self, file_id, path=None):
2329
2416
        """See Tree.get_symlink_target"""
2330
2417
        if not self._content_change(file_id):
2331
2418
            return self._transform._tree.get_symlink_target(file_id)
2471
2558
    file_trans_id = {}
2472
2559
    top_pb = ui.ui_factory.nested_progress_bar()
2473
2560
    pp = ProgressPhase("Build phase", 2, top_pb)
2474
 
    if tree.inventory.root is not None:
 
2561
    if tree.get_root_id() is not None:
2475
2562
        # This is kind of a hack: we should be altering the root
2476
2563
        # as part of the regular tree shape diff logic.
2477
2564
        # The conditional test here is to avoid doing an
2492
2579
        try:
2493
2580
            deferred_contents = []
2494
2581
            num = 0
2495
 
            total = len(tree.inventory)
 
2582
            total = len(tree.all_file_ids())
2496
2583
            if delta_from_tree:
2497
2584
                precomputed_delta = []
2498
2585
            else:
2507
2594
                for dir, files in wt.walkdirs():
2508
2595
                    existing_files.update(f[0] for f in files)
2509
2596
            for num, (tree_path, entry) in \
2510
 
                enumerate(tree.inventory.iter_entries_by_dir()):
2511
 
                pb.update("Building tree", num - len(deferred_contents), total)
 
2597
                enumerate(tree.iter_entries_by_dir()):
 
2598
                pb.update(gettext("Building tree"), num - len(deferred_contents), total)
2512
2599
                if entry.parent_id is None:
2513
2600
                    continue
2514
2601
                reparent = False
2520
2607
                    kind = file_kind(target_path)
2521
2608
                    if kind == "directory":
2522
2609
                        try:
2523
 
                            bzrdir.BzrDir.open(target_path)
 
2610
                            controldir.ControlDir.open(target_path)
2524
2611
                        except errors.NotBranchError:
2525
2612
                            pass
2526
2613
                        else:
2563
2650
            precomputed_delta = None
2564
2651
        conflicts = cook_conflicts(raw_conflicts, tt)
2565
2652
        for conflict in conflicts:
2566
 
            trace.warning(conflict)
 
2653
            trace.warning(unicode(conflict))
2567
2654
        try:
2568
2655
            wt.add_conflicts(conflicts)
2569
2656
        except errors.UnsupportedOperation:
2598
2685
                new_desired_files.append((file_id,
2599
2686
                    (trans_id, tree_path, text_sha1)))
2600
2687
                continue
2601
 
            pb.update('Adding file contents', count + offset, total)
 
2688
            pb.update(gettext('Adding file contents'), count + offset, total)
2602
2689
            if hardlink:
2603
2690
                tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
2604
2691
                                   trans_id)
2625
2712
            contents = filtered_output_bytes(contents, filters,
2626
2713
                ContentFilterContext(tree_path, tree))
2627
2714
        tt.create_file(contents, trans_id, sha1=text_sha1)
2628
 
        pb.update('Adding file contents', count + offset, total)
 
2715
        pb.update(gettext('Adding file contents'), count + offset, total)
2629
2716
 
2630
2717
 
2631
2718
def _reparent_children(tt, old_parent, new_parent):
2745
2832
        tt.set_executability(entry.executable, trans_id)
2746
2833
 
2747
2834
 
2748
 
@deprecated_function(deprecated_in((2, 3, 0)))
2749
 
def get_backup_name(entry, by_parent, parent_trans_id, tt):
2750
 
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
2751
 
 
2752
 
 
2753
 
@deprecated_function(deprecated_in((2, 3, 0)))
2754
 
def _get_backup_name(name, by_parent, parent_trans_id, tt):
2755
 
    """Produce a backup-style name that appears to be available"""
2756
 
    def name_gen():
2757
 
        counter = 1
2758
 
        while True:
2759
 
            yield "%s.~%d~" % (name, counter)
2760
 
            counter += 1
2761
 
    for new_name in name_gen():
2762
 
        if not tt.has_named_child(by_parent, parent_trans_id, new_name):
2763
 
            return new_name
2764
 
 
2765
 
 
2766
 
def _entry_changes(file_id, entry, working_tree):
2767
 
    """Determine in which ways the inventory entry has changed.
2768
 
 
2769
 
    Returns booleans: has_contents, content_mod, meta_mod
2770
 
    has_contents means there are currently contents, but they differ
2771
 
    contents_mod means contents need to be modified
2772
 
    meta_mod means the metadata needs to be modified
2773
 
    """
2774
 
    cur_entry = working_tree.inventory[file_id]
2775
 
    try:
2776
 
        working_kind = working_tree.kind(file_id)
2777
 
        has_contents = True
2778
 
    except NoSuchFile:
2779
 
        has_contents = False
2780
 
        contents_mod = True
2781
 
        meta_mod = False
2782
 
    if has_contents is True:
2783
 
        if entry.kind != working_kind:
2784
 
            contents_mod, meta_mod = True, False
2785
 
        else:
2786
 
            cur_entry._read_tree_state(working_tree.id2path(file_id),
2787
 
                                       working_tree)
2788
 
            contents_mod, meta_mod = entry.detect_changes(cur_entry)
2789
 
            cur_entry._forget_tree_state()
2790
 
    return has_contents, contents_mod, meta_mod
2791
 
 
2792
 
 
2793
2835
def revert(working_tree, target_tree, filenames, backups=False,
2794
2836
           pb=None, change_reporter=None):
2795
2837
    """Revert a working tree's contents to those of a target tree."""
2805
2847
                unversioned_filter=working_tree.is_ignored)
2806
2848
            delta.report_changes(tt.iter_changes(), change_reporter)
2807
2849
        for conflict in conflicts:
2808
 
            trace.warning(conflict)
 
2850
            trace.warning(unicode(conflict))
2809
2851
        pp.next_phase()
2810
2852
        tt.apply()
2811
2853
        working_tree.set_merge_modified(merge_modified)
2842
2884
                 backups, merge_modified, basis_tree=None):
2843
2885
    if basis_tree is not None:
2844
2886
        basis_tree.lock_read()
2845
 
    change_list = target_tree.iter_changes(working_tree,
 
2887
    # We ask the working_tree for its changes relative to the target, rather
 
2888
    # than the target changes relative to the working tree. Because WT4 has an
 
2889
    # optimizer to compare itself to a target, but no optimizer for the
 
2890
    # reverse.
 
2891
    change_list = working_tree.iter_changes(target_tree,
2846
2892
        specific_files=specific_files, pb=pb)
2847
2893
    if target_tree.get_root_id() is None:
2848
2894
        skip_root = True
2852
2898
        deferred_files = []
2853
2899
        for id_num, (file_id, path, changed_content, versioned, parent, name,
2854
2900
                kind, executable) in enumerate(change_list):
2855
 
            if skip_root and file_id[0] is not None and parent[0] is None:
 
2901
            target_path, wt_path = path
 
2902
            target_versioned, wt_versioned = versioned
 
2903
            target_parent, wt_parent = parent
 
2904
            target_name, wt_name = name
 
2905
            target_kind, wt_kind = kind
 
2906
            target_executable, wt_executable = executable
 
2907
            if skip_root and wt_parent is None:
2856
2908
                continue
2857
2909
            trans_id = tt.trans_id_file_id(file_id)
2858
2910
            mode_id = None
2859
2911
            if changed_content:
2860
2912
                keep_content = False
2861
 
                if kind[0] == 'file' and (backups or kind[1] is None):
 
2913
                if wt_kind == 'file' and (backups or target_kind is None):
2862
2914
                    wt_sha1 = working_tree.get_file_sha1(file_id)
2863
2915
                    if merge_modified.get(file_id) != wt_sha1:
2864
2916
                        # acquire the basis tree lazily to prevent the
2867
2919
                        if basis_tree is None:
2868
2920
                            basis_tree = working_tree.basis_tree()
2869
2921
                            basis_tree.lock_read()
2870
 
                        if file_id in basis_tree:
 
2922
                        if basis_tree.has_id(file_id):
2871
2923
                            if wt_sha1 != basis_tree.get_file_sha1(file_id):
2872
2924
                                keep_content = True
2873
 
                        elif kind[1] is None and not versioned[1]:
 
2925
                        elif target_kind is None and not target_versioned:
2874
2926
                            keep_content = True
2875
 
                if kind[0] is not None:
 
2927
                if wt_kind is not None:
2876
2928
                    if not keep_content:
2877
2929
                        tt.delete_contents(trans_id)
2878
 
                    elif kind[1] is not None:
2879
 
                        parent_trans_id = tt.trans_id_file_id(parent[0])
 
2930
                    elif target_kind is not None:
 
2931
                        parent_trans_id = tt.trans_id_file_id(wt_parent)
2880
2932
                        backup_name = tt._available_backup_name(
2881
 
                            name[0], parent_trans_id)
 
2933
                            wt_name, parent_trans_id)
2882
2934
                        tt.adjust_path(backup_name, parent_trans_id, trans_id)
2883
 
                        new_trans_id = tt.create_path(name[0], parent_trans_id)
2884
 
                        if versioned == (True, True):
 
2935
                        new_trans_id = tt.create_path(wt_name, parent_trans_id)
 
2936
                        if wt_versioned and target_versioned:
2885
2937
                            tt.unversion_file(trans_id)
2886
2938
                            tt.version_file(file_id, new_trans_id)
2887
2939
                        # New contents should have the same unix perms as old
2888
2940
                        # contents
2889
2941
                        mode_id = trans_id
2890
2942
                        trans_id = new_trans_id
2891
 
                if kind[1] in ('directory', 'tree-reference'):
 
2943
                if target_kind in ('directory', 'tree-reference'):
2892
2944
                    tt.create_directory(trans_id)
2893
 
                    if kind[1] == 'tree-reference':
 
2945
                    if target_kind == 'tree-reference':
2894
2946
                        revision = target_tree.get_reference_revision(file_id,
2895
 
                                                                      path[1])
 
2947
                                                                      target_path)
2896
2948
                        tt.set_tree_reference(revision, trans_id)
2897
 
                elif kind[1] == 'symlink':
 
2949
                elif target_kind == 'symlink':
2898
2950
                    tt.create_symlink(target_tree.get_symlink_target(file_id),
2899
2951
                                      trans_id)
2900
 
                elif kind[1] == 'file':
 
2952
                elif target_kind == 'file':
2901
2953
                    deferred_files.append((file_id, (trans_id, mode_id)))
2902
2954
                    if basis_tree is None:
2903
2955
                        basis_tree = working_tree.basis_tree()
2904
2956
                        basis_tree.lock_read()
2905
2957
                    new_sha1 = target_tree.get_file_sha1(file_id)
2906
 
                    if (file_id in basis_tree and new_sha1 ==
2907
 
                        basis_tree.get_file_sha1(file_id)):
 
2958
                    if (basis_tree.has_id(file_id) and
 
2959
                        new_sha1 == basis_tree.get_file_sha1(file_id)):
2908
2960
                        if file_id in merge_modified:
2909
2961
                            del merge_modified[file_id]
2910
2962
                    else:
2911
2963
                        merge_modified[file_id] = new_sha1
2912
2964
 
2913
2965
                    # preserve the execute bit when backing up
2914
 
                    if keep_content and executable[0] == executable[1]:
2915
 
                        tt.set_executability(executable[1], trans_id)
2916
 
                elif kind[1] is not None:
2917
 
                    raise AssertionError(kind[1])
2918
 
            if versioned == (False, True):
 
2966
                    if keep_content and wt_executable == target_executable:
 
2967
                        tt.set_executability(target_executable, trans_id)
 
2968
                elif target_kind is not None:
 
2969
                    raise AssertionError(target_kind)
 
2970
            if not wt_versioned and target_versioned:
2919
2971
                tt.version_file(file_id, trans_id)
2920
 
            if versioned == (True, False):
 
2972
            if wt_versioned and not target_versioned:
2921
2973
                tt.unversion_file(trans_id)
2922
 
            if (name[1] is not None and
2923
 
                (name[0] != name[1] or parent[0] != parent[1])):
2924
 
                if name[1] == '' and parent[1] is None:
 
2974
            if (target_name is not None and
 
2975
                (wt_name != target_name or wt_parent != target_parent)):
 
2976
                if target_name == '' and target_parent is None:
2925
2977
                    parent_trans = ROOT_PARENT
2926
2978
                else:
2927
 
                    parent_trans = tt.trans_id_file_id(parent[1])
2928
 
                if parent[0] is None and versioned[0]:
2929
 
                    tt.adjust_root_path(name[1], parent_trans)
 
2979
                    parent_trans = tt.trans_id_file_id(target_parent)
 
2980
                if wt_parent is None and wt_versioned:
 
2981
                    tt.adjust_root_path(target_name, parent_trans)
2930
2982
                else:
2931
 
                    tt.adjust_path(name[1], parent_trans, trans_id)
2932
 
            if executable[0] != executable[1] and kind[1] == "file":
2933
 
                tt.set_executability(executable[1], trans_id)
 
2983
                    tt.adjust_path(target_name, parent_trans, trans_id)
 
2984
            if wt_executable != target_executable and target_kind == "file":
 
2985
                tt.set_executability(target_executable, trans_id)
2934
2986
        if working_tree.supports_content_filtering():
2935
2987
            for index, ((trans_id, mode_id), bytes) in enumerate(
2936
2988
                target_tree.iter_files_bytes(deferred_files)):
2962
3014
    pb = ui.ui_factory.nested_progress_bar()
2963
3015
    try:
2964
3016
        for n in range(10):
2965
 
            pb.update('Resolution pass', n+1, 10)
 
3017
            pb.update(gettext('Resolution pass'), n+1, 10)
2966
3018
            conflicts = tt.find_conflicts()
2967
3019
            if len(conflicts) == 0:
2968
3020
                return new_conflicts
2992
3044
                existing_file, new_file = conflict[2], conflict[1]
2993
3045
            else:
2994
3046
                existing_file, new_file = conflict[1], conflict[2]
2995
 
            new_name = tt.final_name(existing_file)+'.moved'
 
3047
            new_name = tt.final_name(existing_file) + '.moved'
2996
3048
            tt.adjust_path(new_name, final_parent, existing_file)
2997
3049
            new_conflicts.add((c_type, 'Moved existing file to',
2998
3050
                               existing_file, new_file))
3061
3113
        elif c_type == 'unversioned parent':
3062
3114
            file_id = tt.inactive_file_id(conflict[1])
3063
3115
            # special-case the other tree root (move its children instead)
3064
 
            if path_tree and file_id in path_tree:
 
3116
            if path_tree and path_tree.has_id(file_id):
3065
3117
                if path_tree.path2id('') == file_id:
3066
3118
                    # This is the root entry, skip it
3067
3119
                    continue
3085
3137
 
3086
3138
def cook_conflicts(raw_conflicts, tt):
3087
3139
    """Generate a list of cooked conflicts, sorted by file path"""
3088
 
    from bzrlib.conflicts import Conflict
3089
3140
    conflict_iter = iter_cook_conflicts(raw_conflicts, tt)
3090
 
    return sorted(conflict_iter, key=Conflict.sort_key)
 
3141
    return sorted(conflict_iter, key=conflicts.Conflict.sort_key)
3091
3142
 
3092
3143
 
3093
3144
def iter_cook_conflicts(raw_conflicts, tt):
3094
 
    from bzrlib.conflicts import Conflict
3095
3145
    fp = FinalPaths(tt)
3096
3146
    for conflict in raw_conflicts:
3097
3147
        c_type = conflict[0]
3099
3149
        modified_path = fp.get_path(conflict[2])
3100
3150
        modified_id = tt.final_file_id(conflict[2])
3101
3151
        if len(conflict) == 3:
3102
 
            yield Conflict.factory(c_type, action=action, path=modified_path,
3103
 
                                     file_id=modified_id)
 
3152
            yield conflicts.Conflict.factory(
 
3153
                c_type, action=action, path=modified_path, file_id=modified_id)
3104
3154
 
3105
3155
        else:
3106
3156
            conflicting_path = fp.get_path(conflict[3])
3107
3157
            conflicting_id = tt.final_file_id(conflict[3])
3108
 
            yield Conflict.factory(c_type, action=action, path=modified_path,
3109
 
                                   file_id=modified_id,
3110
 
                                   conflict_path=conflicting_path,
3111
 
                                   conflict_file_id=conflicting_id)
 
3158
            yield conflicts.Conflict.factory(
 
3159
                c_type, action=action, path=modified_path,
 
3160
                file_id=modified_id,
 
3161
                conflict_path=conflicting_path,
 
3162
                conflict_file_id=conflicting_id)
3112
3163
 
3113
3164
 
3114
3165
class _FileMover(object):