/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 breezy/transform.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2019-06-04 00:08:59 UTC
  • mfrom: (7122.6.12 win-symlink-warning)
  • Revision ID: breezy.the.bot@gmail.com-20190604000859-2xwms4tkctrj83dm
Allow symbolic links to exist when checking out trees on Windows.

Merged from https://code.launchpad.net/~jelmer/brz/win-symlink-warning/+merge/363900

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 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
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
 
from bzrlib.lazy_import import lazy_import
23
 
lazy_import(globals(), """
24
 
from bzrlib import (
 
24
from . import (
 
25
    config as _mod_config,
 
26
    errors,
 
27
    lazy_import,
 
28
    registry,
 
29
    trace,
 
30
    tree,
 
31
    )
 
32
lazy_import.lazy_import(globals(), """
 
33
from breezy import (
25
34
    annotate,
26
35
    bencode,
27
 
    bzrdir,
 
36
    controldir,
 
37
    commit,
 
38
    conflicts,
28
39
    delta,
29
 
    errors,
30
 
    inventory,
 
40
    lock,
31
41
    multiparent,
32
42
    osutils,
33
43
    revision as _mod_revision,
34
44
    ui,
35
 
    )
 
45
    urlutils,
 
46
    )
 
47
from breezy.bzr import (
 
48
    inventory,
 
49
    inventorytree,
 
50
    )
 
51
from breezy.i18n import gettext
36
52
""")
37
 
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
38
 
                           ReusingTransform, CantMoveRoot,
39
 
                           ExistingLimbo, ImmortalLimbo, NoFinalPath,
40
 
                           UnableCreateSymlink)
41
 
from bzrlib.filters import filtered_output_bytes, ContentFilterContext
42
 
from bzrlib.inventory import InventoryEntry
43
 
from bzrlib.osutils import (
 
53
from .errors import (DuplicateKey, MalformedTransform,
 
54
                     ReusingTransform, CantMoveRoot,
 
55
                     ImmortalLimbo, NoFinalPath)
 
56
from .filters import filtered_output_bytes, ContentFilterContext
 
57
from .mutabletree import MutableTree
 
58
from .osutils import (
44
59
    delete_any,
45
60
    file_kind,
46
 
    has_symlinks,
47
 
    lexists,
48
61
    pathjoin,
49
62
    sha_file,
50
63
    splitpath,
51
 
    supports_executable,
52
 
)
53
 
from bzrlib.progress import ProgressPhase
54
 
from bzrlib.symbol_versioning import (
55
 
        deprecated_function,
56
 
        deprecated_in,
57
 
        )
58
 
from bzrlib.trace import mutter, warning
59
 
from bzrlib import tree
60
 
import bzrlib.ui
61
 
import bzrlib.urlutils as urlutils
 
64
    supports_symlinks,
 
65
    )
 
66
from .progress import ProgressPhase
 
67
from .sixish import (
 
68
    text_type,
 
69
    viewitems,
 
70
    viewvalues,
 
71
    )
 
72
from .tree import (
 
73
    find_previous_path,
 
74
    )
62
75
 
63
76
 
64
77
ROOT_PARENT = "root-parent"
80
93
class TreeTransformBase(object):
81
94
    """The base class for TreeTransform and its kin."""
82
95
 
83
 
    def __init__(self, tree, pb=None,
84
 
                 case_sensitive=True):
 
96
    def __init__(self, tree, pb=None, case_sensitive=True):
85
97
        """Constructor.
86
98
 
87
99
        :param tree: The tree that will be transformed, but not necessarily
99
111
        self._new_parent = {}
100
112
        # mapping of trans_id with new contents -> new file_kind
101
113
        self._new_contents = {}
 
114
        # mapping of trans_id => (sha1 of content, stat_value)
 
115
        self._observed_sha1s = {}
102
116
        # Set of trans_ids whose contents will be removed
103
117
        self._removed_contents = set()
104
118
        # Mapping of trans_id -> new execute-bit value
118
132
        # Mapping trans_id -> path in old tree
119
133
        self._tree_id_paths = {}
120
134
        # The trans_id that will be used as the tree root
121
 
        root_id = tree.get_root_id()
122
 
        if root_id is not None:
123
 
            self._new_root = self.trans_id_tree_file_id(root_id)
 
135
        if tree.is_versioned(''):
 
136
            self._new_root = self.trans_id_tree_path('')
124
137
        else:
125
138
            self._new_root = None
126
 
        # Indictor of whether the transform has been applied
 
139
        # Indicator of whether the transform has been applied
127
140
        self._done = False
128
141
        # A progress bar
129
142
        self._pb = pb
132
145
        # A counter of how many files have been renamed
133
146
        self.rename_count = 0
134
147
 
 
148
    def __enter__(self):
 
149
        """Support Context Manager API."""
 
150
        return self
 
151
 
 
152
    def __exit__(self, exc_type, exc_val, exc_tb):
 
153
        """Support Context Manager API."""
 
154
        self.finalize()
 
155
 
135
156
    def finalize(self):
136
157
        """Release the working tree lock, if held.
137
158
 
140
161
        """
141
162
        if self._tree is None:
142
163
            return
 
164
        for hook in MutableTree.hooks['post_transform']:
 
165
            hook(self._tree, self)
143
166
        self._tree.unlock()
144
167
        self._tree = None
145
168
 
151
174
    def _assign_id(self):
152
175
        """Produce a new tranform id"""
153
176
        new_id = "new-%s" % self._id_number
154
 
        self._id_number +=1
 
177
        self._id_number += 1
155
178
        return new_id
156
179
 
157
180
    def create_path(self, name, parent):
194
217
        # the physical root needs a new transaction id
195
218
        self._tree_path_ids.pop("")
196
219
        self._tree_id_paths.pop(old_root)
197
 
        self._new_root = self.trans_id_tree_file_id(self._tree.get_root_id())
 
220
        self._new_root = self.trans_id_tree_path('')
198
221
        if parent == old_root:
199
222
            parent = self._new_root
200
223
        self.adjust_path(name, parent, old_root)
212
235
        This means that the old root trans-id becomes obsolete, so it is
213
236
        recommended only to invoke this after the root trans-id has become
214
237
        irrelevant.
 
238
 
215
239
        """
216
 
        new_roots = [k for k, v in self._new_parent.iteritems() if v is
217
 
                     ROOT_PARENT]
 
240
        new_roots = [k for k, v in viewitems(self._new_parent)
 
241
                     if v == ROOT_PARENT]
218
242
        if len(new_roots) < 1:
219
243
            return
220
244
        if len(new_roots) != 1:
223
247
            self._new_root = new_roots[0]
224
248
            return
225
249
        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
250
        # unversion the new root's directory.
232
 
        file_id = self.final_file_id(old_new_root)
 
251
        if self.final_kind(self._new_root) is None:
 
252
            file_id = self.final_file_id(old_new_root)
 
253
        else:
 
254
            file_id = self.final_file_id(self._new_root)
233
255
        if old_new_root in self._new_id:
234
256
            self.cancel_versioning(old_new_root)
235
257
        else:
236
258
            self.unversion_file(old_new_root)
237
259
        # if, at this stage, root still has an old file_id, zap it so we can
238
260
        # 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):
 
261
        if (self.tree_file_id(self._new_root) is not None
 
262
                and self._new_root not in self._removed_id):
241
263
            self.unversion_file(self._new_root)
242
 
        self.version_file(file_id, self._new_root)
 
264
        if file_id is not None:
 
265
            self.version_file(file_id, self._new_root)
243
266
 
244
267
        # Now move children of new root into old root directory.
245
268
        # Ensure all children are registered with the transaction, but don't
263
286
        del self._new_parent[old_new_root]
264
287
        del self._new_name[old_new_root]
265
288
 
266
 
    def trans_id_tree_file_id(self, inventory_id):
267
 
        """Determine the transaction id of a working tree file.
268
 
 
269
 
        This reflects only files that already exist, not ones that will be
270
 
        added by transactions.
271
 
        """
272
 
        if inventory_id is None:
273
 
            raise ValueError('None is not a valid file id')
274
 
        path = self._tree.id2path(inventory_id)
275
 
        return self.trans_id_tree_path(path)
276
 
 
277
289
    def trans_id_file_id(self, file_id):
278
290
        """Determine or set the transaction id associated with a file ID.
279
291
        A new id is only created for file_ids that were never present.  If
286
298
            return self._r_new_id[file_id]
287
299
        else:
288
300
            try:
289
 
                self._tree.iter_entries_by_dir([file_id]).next()
290
 
            except StopIteration:
 
301
                path = self._tree.id2path(file_id)
 
302
            except errors.NoSuchId:
291
303
                if file_id in self._non_present_ids:
292
304
                    return self._non_present_ids[file_id]
293
305
                else:
295
307
                    self._non_present_ids[file_id] = trans_id
296
308
                    return trans_id
297
309
            else:
298
 
                return self.trans_id_tree_file_id(file_id)
 
310
                return self.trans_id_tree_path(path)
299
311
 
300
312
    def trans_id_tree_path(self, path):
301
313
        """Determine (and maybe set) the transaction ID for a tree path."""
314
326
 
315
327
    def delete_contents(self, trans_id):
316
328
        """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)
 
329
        kind = self.tree_kind(trans_id)
 
330
        if kind is not None:
 
331
            self._removed_contents.add(trans_id)
321
332
 
322
333
    def cancel_deletion(self, trans_id):
323
334
        """Cancel a scheduled deletion"""
380
391
        return sorted(FinalPaths(self).get_paths(new_ids))
381
392
 
382
393
    def _inventory_altered(self):
383
 
        """Get the trans_ids and paths of files needing new inv entries."""
384
 
        new_ids = set()
385
 
        for id_set in [self._new_name, self._new_parent, self._new_id,
 
394
        """Determine which trans_ids need new Inventory entries.
 
395
 
 
396
        An new entry is needed when anything that would be reflected by an
 
397
        inventory entry changes, including file name, file_id, parent file_id,
 
398
        file kind, and the execute bit.
 
399
 
 
400
        Some care is taken to return entries with real changes, not cases
 
401
        where the value is deleted and then restored to its original value,
 
402
        but some actually unchanged values may be returned.
 
403
 
 
404
        :returns: A list of (path, trans_id) for all items requiring an
 
405
            inventory change. Ordered by path.
 
406
        """
 
407
        changed_ids = set()
 
408
        # Find entries whose file_ids are new (or changed).
 
409
        new_file_id = set(t for t in self._new_id
 
410
                          if self._new_id[t] != self.tree_file_id(t))
 
411
        for id_set in [self._new_name, self._new_parent, new_file_id,
386
412
                       self._new_executability]:
387
 
            new_ids.update(id_set)
 
413
            changed_ids.update(id_set)
 
414
        # removing implies a kind change
388
415
        changed_kind = set(self._removed_contents)
 
416
        # so does adding
389
417
        changed_kind.intersection_update(self._new_contents)
390
 
        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))
393
 
        new_ids.update(changed_kind)
394
 
        return sorted(FinalPaths(self).get_paths(new_ids))
 
418
        # Ignore entries that are already known to have changed.
 
419
        changed_kind.difference_update(changed_ids)
 
420
        #  to keep only the truly changed ones
 
421
        changed_kind = (t for t in changed_kind
 
422
                        if self.tree_kind(t) != self.final_kind(t))
 
423
        # all kind changes will alter the inventory
 
424
        changed_ids.update(changed_kind)
 
425
        # To find entries with changed parent_ids, find parents which existed,
 
426
        # but changed file_id.
 
427
        # Now add all their children to the set.
 
428
        for parent_trans_id in new_file_id:
 
429
            changed_ids.update(self.iter_tree_children(parent_trans_id))
 
430
        return sorted(FinalPaths(self).get_paths(changed_ids))
395
431
 
396
432
    def final_kind(self, trans_id):
397
433
        """Determine the final file kind, after any changes applied.
398
434
 
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)
 
435
        :return: None if the file does not exist/has no contents.  (It is
 
436
            conceivable that a path would be created without the corresponding
 
437
            contents insertion command)
402
438
        """
403
439
        if trans_id in self._new_contents:
404
440
            return self._new_contents[trans_id]
405
441
        elif trans_id in self._removed_contents:
406
 
            raise NoSuchFile(None)
 
442
            return None
407
443
        else:
408
444
            return self.tree_kind(trans_id)
409
445
 
 
446
    def tree_path(self, trans_id):
 
447
        """Determine the tree path associated with the trans_id."""
 
448
        return self._tree_id_paths.get(trans_id)
 
449
 
410
450
    def tree_file_id(self, trans_id):
411
451
        """Determine the file id associated with the trans_id in the tree"""
412
 
        try:
413
 
            path = self._tree_id_paths[trans_id]
414
 
        except KeyError:
415
 
            # the file is a new, unversioned file, or invalid trans_id
 
452
        path = self.tree_path(trans_id)
 
453
        if path is None:
416
454
            return None
417
455
        # the file is old; the old id is still valid
418
456
        if self._new_root == trans_id:
440
478
        file_id = self.tree_file_id(trans_id)
441
479
        if file_id is not None:
442
480
            return file_id
443
 
        for key, value in self._non_present_ids.iteritems():
 
481
        for key, value in viewitems(self._non_present_ids):
444
482
            if value == trans_id:
445
483
                return key
446
484
 
470
508
        Only new paths and parents of tree files with assigned ids are used.
471
509
        """
472
510
        by_parent = {}
473
 
        items = list(self._new_parent.iteritems())
474
 
        items.extend((t, self.final_parent(t)) for t in
475
 
                      self._tree_id_paths.keys())
 
511
        items = list(viewitems(self._new_parent))
 
512
        items.extend((t, self.final_parent(t))
 
513
                     for t in list(self._tree_id_paths))
476
514
        for trans_id, parent_id in items:
477
515
            if parent_id not in by_parent:
478
516
                by_parent[parent_id] = set()
516
554
        Active parents are those which gain children, and those which are
517
555
        removed.  This is a necessary first step in detecting conflicts.
518
556
        """
519
 
        parents = self.by_parent().keys()
 
557
        parents = list(self.by_parent())
520
558
        parents.extend([t for t in self._removed_contents if
521
559
                        self.tree_kind(t) == 'directory'])
522
560
        for trans_id in self._removed_id:
523
 
            file_id = self.tree_file_id(trans_id)
524
 
            if file_id is not None:
525
 
                if self._tree.inventory[file_id].kind == 'directory':
 
561
            path = self.tree_path(trans_id)
 
562
            if path is not None:
 
563
                if self._tree.stored_kind(path) == 'directory':
526
564
                    parents.append(trans_id)
527
565
            elif self.tree_kind(trans_id) == 'directory':
528
566
                parents.append(trans_id)
531
569
            # ensure that all children are registered with the transaction
532
570
            list(self.iter_tree_children(parent_id))
533
571
 
534
 
    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:
 
572
    def _has_named_child(self, name, parent_id, known_children):
 
573
        """Does a parent already have a name child.
 
574
 
 
575
        :param name: The searched for name.
 
576
 
 
577
        :param parent_id: The parent for which the check is made.
 
578
 
 
579
        :param known_children: The already known children. This should have
 
580
            been recently obtained from `self.by_parent.get(parent_id)`
 
581
            (or will be if None is passed).
 
582
        """
 
583
        if known_children is None:
 
584
            known_children = self.by_parent().get(parent_id, [])
 
585
        for child in known_children:
540
586
            if self.final_name(child) == name:
541
587
                return True
542
 
        try:
543
 
            path = self._tree_id_paths[parent_id]
544
 
        except KeyError:
 
588
        parent_path = self._tree_id_paths.get(parent_id, None)
 
589
        if parent_path is None:
 
590
            # No parent... no children
545
591
            return False
546
 
        childpath = joinpath(path, name)
547
 
        child_id = self._tree_path_ids.get(childpath)
 
592
        child_path = joinpath(parent_path, name)
 
593
        child_id = self._tree_path_ids.get(child_path, None)
548
594
        if child_id is None:
549
 
            return lexists(self._tree.abspath(childpath))
 
595
            # Not known by the tree transform yet, check the filesystem
 
596
            return osutils.lexists(self._tree.abspath(child_path))
550
597
        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
 
598
            raise AssertionError('child_id is missing: %s, %s, %s'
 
599
                                 % (name, parent_id, child_id))
 
600
 
 
601
    def _available_backup_name(self, name, target_id):
 
602
        """Find an available backup name.
 
603
 
 
604
        :param name: The basename of the file.
 
605
 
 
606
        :param target_id: The directory trans_id where the backup should
 
607
            be placed.
 
608
        """
 
609
        known_children = self.by_parent().get(target_id, [])
 
610
        return osutils.available_backup_name(
 
611
            name,
 
612
            lambda base: self._has_named_child(
 
613
                base, target_id, known_children))
558
614
 
559
615
    def _parent_loops(self):
560
616
        """No entry should be its own ancestor"""
562
618
        for trans_id in self._new_parent:
563
619
            seen = set()
564
620
            parent_id = trans_id
565
 
            while parent_id is not ROOT_PARENT:
 
621
            while parent_id != ROOT_PARENT:
566
622
                seen.add(parent_id)
567
623
                try:
568
624
                    parent_id = self.final_parent(parent_id)
577
633
    def _unversioned_parents(self, by_parent):
578
634
        """If parent directories are versioned, children must be versioned."""
579
635
        conflicts = []
580
 
        for parent_id, children in by_parent.iteritems():
581
 
            if parent_id is ROOT_PARENT:
 
636
        for parent_id, children in viewitems(by_parent):
 
637
            if parent_id == ROOT_PARENT:
582
638
                continue
583
639
            if self.final_file_id(parent_id) is not None:
584
640
                continue
585
641
            for child_id in children:
586
642
                if self.final_file_id(child_id) is not None:
587
643
                    conflicts.append(('unversioned parent', parent_id))
588
 
                    break;
 
644
                    break
589
645
        return conflicts
590
646
 
591
647
    def _improper_versioning(self):
594
650
        However, existing entries with no contents are okay.
595
651
        """
596
652
        conflicts = []
597
 
        for trans_id in self._new_id.iterkeys():
598
 
            try:
599
 
                kind = self.final_kind(trans_id)
600
 
            except NoSuchFile:
 
653
        for trans_id in self._new_id:
 
654
            kind = self.final_kind(trans_id)
 
655
            if kind == 'symlink' and not self._tree.supports_symlinks():
 
656
                # Ignore symlinks as they are not supported on this platform
 
657
                continue
 
658
            if kind is None:
601
659
                conflicts.append(('versioning no contents', trans_id))
602
660
                continue
603
 
            if not InventoryEntry.versionable_kind(kind):
 
661
            if not self._tree.versionable_kind(kind):
604
662
                conflicts.append(('versioning bad kind', trans_id, kind))
605
663
        return conflicts
606
664
 
617
675
            if self.final_file_id(trans_id) is None:
618
676
                conflicts.append(('unversioned executability', trans_id))
619
677
            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:
 
678
                if self.final_kind(trans_id) != "file":
625
679
                    conflicts.append(('non-file executability', trans_id))
626
680
        return conflicts
627
681
 
629
683
        """Check for overwrites (not permitted on Win32)"""
630
684
        conflicts = []
631
685
        for trans_id in self._new_contents:
632
 
            try:
633
 
                self.tree_kind(trans_id)
634
 
            except NoSuchFile:
 
686
            if self.tree_kind(trans_id) is None:
635
687
                continue
636
688
            if trans_id not in self._removed_contents:
637
689
                conflicts.append(('overwrite', trans_id,
638
 
                                 self.final_name(trans_id)))
 
690
                                  self.final_name(trans_id)))
639
691
        return conflicts
640
692
 
641
693
    def _duplicate_entries(self, by_parent):
643
695
        conflicts = []
644
696
        if (self._new_name, self._new_parent) == ({}, {}):
645
697
            return conflicts
646
 
        for children in by_parent.itervalues():
647
 
            name_ids = [(self.final_name(t), t) for t in children]
648
 
            if not self._case_sensitive_target:
649
 
                name_ids = [(n.lower(), t) for n, t in name_ids]
 
698
        for children in viewvalues(by_parent):
 
699
            name_ids = []
 
700
            for child_tid in children:
 
701
                name = self.final_name(child_tid)
 
702
                if name is not None:
 
703
                    # Keep children only if they still exist in the end
 
704
                    if not self._case_sensitive_target:
 
705
                        name = name.lower()
 
706
                    name_ids.append((name, child_tid))
650
707
            name_ids.sort()
651
708
            last_name = None
652
709
            last_trans_id = None
653
710
            for name, trans_id in name_ids:
654
 
                try:
655
 
                    kind = self.final_kind(trans_id)
656
 
                except NoSuchFile:
657
 
                    kind = None
 
711
                kind = self.final_kind(trans_id)
658
712
                file_id = self.final_file_id(trans_id)
659
713
                if kind is None and file_id is None:
660
714
                    continue
661
715
                if name == last_name:
662
716
                    conflicts.append(('duplicate', last_trans_id, trans_id,
663
 
                    name))
 
717
                                      name))
664
718
                last_name = name
665
719
                last_trans_id = trans_id
666
720
        return conflicts
668
722
    def _duplicate_ids(self):
669
723
        """Each inventory id may only be used once"""
670
724
        conflicts = []
 
725
        try:
 
726
            all_ids = self._tree.all_file_ids()
 
727
        except errors.UnsupportedOperation:
 
728
            # it's okay for non-file-id trees to raise UnsupportedOperation.
 
729
            return []
671
730
        removed_tree_ids = set((self.tree_file_id(trans_id) for trans_id in
672
731
                                self._removed_id))
673
 
        all_ids = self._tree.all_file_ids()
674
732
        active_tree_ids = all_ids.difference(removed_tree_ids)
675
 
        for trans_id, file_id in self._new_id.iteritems():
 
733
        for trans_id, file_id in viewitems(self._new_id):
676
734
            if file_id in active_tree_ids:
677
 
                old_trans_id = self.trans_id_tree_file_id(file_id)
 
735
                path = self._tree.id2path(file_id)
 
736
                old_trans_id = self.trans_id_tree_path(path)
678
737
                conflicts.append(('duplicate id', old_trans_id, trans_id))
679
738
        return conflicts
680
739
 
681
740
    def _parent_type_conflicts(self, by_parent):
682
 
        """parents must have directory 'contents'."""
 
741
        """Children must have a directory parent"""
683
742
        conflicts = []
684
 
        for parent_id, children in by_parent.iteritems():
685
 
            if parent_id is ROOT_PARENT:
686
 
                continue
687
 
            if not self._any_contents(children):
688
 
                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
 
743
        for parent_id, children in viewitems(by_parent):
 
744
            if parent_id == ROOT_PARENT:
 
745
                continue
 
746
            no_children = True
 
747
            for child_id in children:
 
748
                if self.final_kind(child_id) is not None:
 
749
                    no_children = False
 
750
                    break
 
751
            if no_children:
 
752
                continue
 
753
            # There is at least a child, so we need an existing directory to
 
754
            # contain it.
 
755
            kind = self.final_kind(parent_id)
698
756
            if kind is None:
 
757
                # The directory will be deleted
699
758
                conflicts.append(('missing parent', parent_id))
700
759
            elif kind != "directory":
 
760
                # Meh, we need a *directory* to put something in it
701
761
                conflicts.append(('non-directory parent', parent_id))
702
762
        return conflicts
703
763
 
704
 
    def _any_contents(self, trans_ids):
705
 
        """Return true if any of the trans_ids, will have contents."""
706
 
        for trans_id in trans_ids:
707
 
            try:
708
 
                kind = self.final_kind(trans_id)
709
 
            except NoSuchFile:
710
 
                continue
711
 
            return True
712
 
        return False
713
 
 
714
764
    def _set_executability(self, path, trans_id):
715
765
        """Set the executability of versioned files """
716
 
        if supports_executable():
 
766
        if self._tree._supports_executable():
717
767
            new_executability = self._new_executability[trans_id]
718
768
            abspath = self._tree.abspath(path)
719
769
            current_mode = os.stat(abspath).st_mode
720
770
            if new_executability:
721
771
                umask = os.umask(0)
722
772
                os.umask(umask)
723
 
                to_mode = current_mode | (0100 & ~umask)
 
773
                to_mode = current_mode | (0o100 & ~umask)
724
774
                # Enable x-bit for others only if they can read it.
725
 
                if current_mode & 0004:
726
 
                    to_mode |= 0001 & ~umask
727
 
                if current_mode & 0040:
728
 
                    to_mode |= 0010 & ~umask
 
775
                if current_mode & 0o004:
 
776
                    to_mode |= 0o001 & ~umask
 
777
                if current_mode & 0o040:
 
778
                    to_mode |= 0o010 & ~umask
729
779
            else:
730
 
                to_mode = current_mode & ~0111
731
 
            os.chmod(abspath, to_mode)
 
780
                to_mode = current_mode & ~0o111
 
781
            osutils.chmod_if_possible(abspath, to_mode)
732
782
 
733
783
    def _new_entry(self, name, parent_id, file_id):
734
784
        """Helper function to create a new filesystem entry."""
738
788
        return trans_id
739
789
 
740
790
    def new_file(self, name, parent_id, contents, file_id=None,
741
 
                 executable=None):
 
791
                 executable=None, sha1=None):
742
792
        """Convenience method to create files.
743
793
 
744
794
        name is the name of the file to create.
751
801
        trans_id = self._new_entry(name, parent_id, file_id)
752
802
        # TODO: rather than scheduling a set_executable call,
753
803
        # have create_file create the file with the right mode.
754
 
        self.create_file(contents, trans_id)
 
804
        self.create_file(contents, trans_id, sha1=sha1)
755
805
        if executable is not None:
756
806
            self.set_executability(executable, trans_id)
757
807
        return trans_id
780
830
        self.create_symlink(target, trans_id)
781
831
        return trans_id
782
832
 
 
833
    def new_orphan(self, trans_id, parent_id):
 
834
        """Schedule an item to be orphaned.
 
835
 
 
836
        When a directory is about to be removed, its children, if they are not
 
837
        versioned are moved out of the way: they don't have a parent anymore.
 
838
 
 
839
        :param trans_id: The trans_id of the existing item.
 
840
        :param parent_id: The parent trans_id of the item.
 
841
        """
 
842
        raise NotImplementedError(self.new_orphan)
 
843
 
 
844
    def _get_potential_orphans(self, dir_id):
 
845
        """Find the potential orphans in a directory.
 
846
 
 
847
        A directory can't be safely deleted if there are versioned files in it.
 
848
        If all the contained files are unversioned then they can be orphaned.
 
849
 
 
850
        The 'None' return value means that the directory contains at least one
 
851
        versioned file and should not be deleted.
 
852
 
 
853
        :param dir_id: The directory trans id.
 
854
 
 
855
        :return: A list of the orphan trans ids or None if at least one
 
856
             versioned file is present.
 
857
        """
 
858
        orphans = []
 
859
        # Find the potential orphans, stop if one item should be kept
 
860
        for child_tid in self.by_parent()[dir_id]:
 
861
            if child_tid in self._removed_contents:
 
862
                # The child is removed as part of the transform. Since it was
 
863
                # versioned before, it's not an orphan
 
864
                continue
 
865
            elif self.final_file_id(child_tid) is None:
 
866
                # The child is not versioned
 
867
                orphans.append(child_tid)
 
868
            else:
 
869
                # We have a versioned file here, searching for orphans is
 
870
                # meaningless.
 
871
                orphans = None
 
872
                break
 
873
        return orphans
 
874
 
783
875
    def _affected_ids(self):
784
876
        """Return the set of transform ids affected by the transform"""
785
877
        trans_ids = set(self._removed_id)
786
 
        trans_ids.update(self._new_id.keys())
 
878
        trans_ids.update(self._new_id)
787
879
        trans_ids.update(self._removed_contents)
788
 
        trans_ids.update(self._new_contents.keys())
789
 
        trans_ids.update(self._new_executability.keys())
790
 
        trans_ids.update(self._new_name.keys())
791
 
        trans_ids.update(self._new_parent.keys())
 
880
        trans_ids.update(self._new_contents)
 
881
        trans_ids.update(self._new_executability)
 
882
        trans_ids.update(self._new_name)
 
883
        trans_ids.update(self._new_parent)
792
884
        return trans_ids
793
885
 
794
886
    def _get_file_id_maps(self):
807
899
                to_trans_ids[to_file_id] = trans_id
808
900
        return from_trans_ids, to_trans_ids
809
901
 
810
 
    def _from_file_data(self, from_trans_id, from_versioned, file_id):
 
902
    def _from_file_data(self, from_trans_id, from_versioned, from_path):
811
903
        """Get data about a file in the from (tree) state
812
904
 
813
905
        Return a (name, parent, kind, executable) tuple
815
907
        from_path = self._tree_id_paths.get(from_trans_id)
816
908
        if from_versioned:
817
909
            # get data from working tree if versioned
818
 
            from_entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
 
910
            from_entry = next(self._tree.iter_entries_by_dir(
 
911
                specific_files=[from_path]))[1]
819
912
            from_name = from_entry.name
820
913
            from_parent = from_entry.parent_id
821
914
        else:
844
937
        Return a (name, parent, kind, executable) tuple
845
938
        """
846
939
        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
 
940
        to_kind = self.final_kind(to_trans_id)
851
941
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
852
942
        if to_trans_id in self._new_executability:
853
943
            to_executable = self._new_executability[to_trans_id]
871
961
        from_trans_ids, to_trans_ids = self._get_file_id_maps()
872
962
        results = []
873
963
        # Now iterate through all active file_ids
874
 
        for file_id in set(from_trans_ids.keys() + to_trans_ids.keys()):
 
964
        for file_id in set(from_trans_ids).union(to_trans_ids):
875
965
            modified = False
876
966
            from_trans_id = from_trans_ids.get(file_id)
877
967
            # find file ids, and determine versioning state
887
977
            else:
888
978
                to_versioned = True
889
979
 
890
 
            from_name, from_parent, from_kind, from_executable = \
891
 
                self._from_file_data(from_trans_id, from_versioned, file_id)
892
 
 
893
 
            to_name, to_parent, to_kind, to_executable = \
894
 
                self._to_file_data(to_trans_id, from_trans_id, from_executable)
895
 
 
896
980
            if not from_versioned:
897
981
                from_path = None
898
982
            else:
901
985
                to_path = None
902
986
            else:
903
987
                to_path = final_paths.get_path(to_trans_id)
 
988
 
 
989
            from_name, from_parent, from_kind, from_executable = \
 
990
                self._from_file_data(from_trans_id, from_versioned, from_path)
 
991
 
 
992
            to_name, to_parent, to_kind, to_executable = \
 
993
                self._to_file_data(to_trans_id, from_trans_id, from_executable)
 
994
 
904
995
            if from_kind != to_kind:
905
996
                modified = True
906
997
            elif to_kind in ('file', 'symlink') and (
907
 
                to_trans_id != from_trans_id or
908
 
                to_trans_id in self._new_contents):
 
998
                    to_trans_id != from_trans_id
 
999
                    or to_trans_id in self._new_contents):
909
1000
                modified = True
910
 
            if (not modified and from_versioned == to_versioned and
911
 
                from_parent==to_parent and from_name == to_name and
912
 
                from_executable == to_executable):
 
1001
            if (not modified and from_versioned == to_versioned
 
1002
                and from_parent == to_parent and from_name == to_name
 
1003
                    and from_executable == to_executable):
913
1004
                continue
914
1005
            results.append((file_id, (from_path, to_path), modified,
915
 
                   (from_versioned, to_versioned),
916
 
                   (from_parent, to_parent),
917
 
                   (from_name, to_name),
918
 
                   (from_kind, to_kind),
919
 
                   (from_executable, to_executable)))
920
 
        return iter(sorted(results, key=lambda x:x[1]))
 
1006
                            (from_versioned, to_versioned),
 
1007
                            (from_parent, to_parent),
 
1008
                            (from_name, to_name),
 
1009
                            (from_kind, to_kind),
 
1010
                            (from_executable, to_executable)))
 
1011
 
 
1012
        def path_key(t):
 
1013
            paths = t[1]
 
1014
            return (paths[0] or '', paths[1] or '')
 
1015
        return iter(sorted(results, key=path_key))
921
1016
 
922
1017
    def get_preview_tree(self):
923
1018
        """Return a tree representing the result of the transform.
927
1022
        """
928
1023
        return _PreviewTree(self)
929
1024
 
930
 
    def commit(self, branch, message, merge_parents=None, strict=False):
 
1025
    def commit(self, branch, message, merge_parents=None, strict=False,
 
1026
               timestamp=None, timezone=None, committer=None, authors=None,
 
1027
               revprops=None, revision_id=None):
931
1028
        """Commit the result of this TreeTransform to a branch.
932
1029
 
933
1030
        :param branch: The branch to commit to.
934
1031
        :param message: The message to attach to the commit.
935
 
        :param merge_parents: Additional parents specified by pending merges.
 
1032
        :param merge_parents: Additional parent revision-ids specified by
 
1033
            pending merges.
 
1034
        :param strict: If True, abort the commit if there are unversioned
 
1035
            files.
 
1036
        :param timestamp: if not None, seconds-since-epoch for the time and
 
1037
            date.  (May be a float.)
 
1038
        :param timezone: Optional timezone for timestamp, as an offset in
 
1039
            seconds.
 
1040
        :param committer: Optional committer in email-id format.
 
1041
            (e.g. "J Random Hacker <jrandom@example.com>")
 
1042
        :param authors: Optional list of authors in email-id format.
 
1043
        :param revprops: Optional dictionary of revision properties.
 
1044
        :param revision_id: Optional revision id.  (Specifying a revision-id
 
1045
            may reduce performance for some non-native formats.)
936
1046
        :return: The revision_id of the revision committed.
937
1047
        """
938
1048
        self._check_malformed()
954
1064
                parent_ids.extend(merge_parents)
955
1065
        if self._tree.get_revision_id() != last_rev_id:
956
1066
            raise ValueError('TreeTransform not based on branch basis: %s' %
957
 
                             self._tree.get_revision_id())
958
 
        builder = branch.get_commit_builder(parent_ids)
 
1067
                             self._tree.get_revision_id().decode('utf-8'))
 
1068
        revprops = commit.Commit.update_revprops(revprops, branch, authors)
 
1069
        builder = branch.get_commit_builder(parent_ids,
 
1070
                                            timestamp=timestamp,
 
1071
                                            timezone=timezone,
 
1072
                                            committer=committer,
 
1073
                                            revprops=revprops,
 
1074
                                            revision_id=revision_id)
959
1075
        preview = self.get_preview_tree()
960
1076
        list(builder.record_iter_changes(preview, last_rev_id,
961
1077
                                         self.iter_changes()))
965
1081
        return revision_id
966
1082
 
967
1083
    def _text_parent(self, trans_id):
968
 
        file_id = self.tree_file_id(trans_id)
 
1084
        path = self.tree_path(trans_id)
969
1085
        try:
970
 
            if file_id is None or self._tree.kind(file_id) != 'file':
 
1086
            if path is None or self._tree.kind(path) != 'file':
971
1087
                return None
972
1088
        except errors.NoSuchFile:
973
1089
            return None
974
 
        return file_id
 
1090
        return path
975
1091
 
976
1092
    def _get_parents_texts(self, trans_id):
977
1093
        """Get texts for compression parents of this file."""
978
 
        file_id = self._text_parent(trans_id)
979
 
        if file_id is None:
 
1094
        path = self._text_parent(trans_id)
 
1095
        if path is None:
980
1096
            return ()
981
 
        return (self._tree.get_file_text(file_id),)
 
1097
        return (self._tree.get_file_text(path),)
982
1098
 
983
1099
    def _get_parents_lines(self, trans_id):
984
1100
        """Get lines for compression parents of this file."""
985
 
        file_id = self._text_parent(trans_id)
986
 
        if file_id is None:
 
1101
        path = self._text_parent(trans_id)
 
1102
        if path is None:
987
1103
            return ()
988
 
        return (self._tree.get_file_lines(file_id),)
 
1104
        return (self._tree.get_file_lines(path),)
989
1105
 
990
1106
    def serialize(self, serializer):
991
1107
        """Serialize this TreeTransform.
992
1108
 
993
1109
        :param serializer: A Serialiser like pack.ContainerSerializer.
994
1110
        """
995
 
        new_name = dict((k, v.encode('utf-8')) for k, v in
996
 
                        self._new_name.items())
997
 
        new_executability = dict((k, int(v)) for k, v in
998
 
                                 self._new_executability.items())
999
 
        tree_path_ids = dict((k.encode('utf-8'), v)
1000
 
                             for k, v in self._tree_path_ids.items())
 
1111
        new_name = {k.encode('utf-8'): v.encode('utf-8')
 
1112
                    for k, v in viewitems(self._new_name)}
 
1113
        new_parent = {k.encode('utf-8'): v.encode('utf-8')
 
1114
                      for k, v in viewitems(self._new_parent)}
 
1115
        new_id = {k.encode('utf-8'): v
 
1116
                  for k, v in viewitems(self._new_id)}
 
1117
        new_executability = {k.encode('utf-8'): int(v)
 
1118
                             for k, v in viewitems(self._new_executability)}
 
1119
        tree_path_ids = {k.encode('utf-8'): v.encode('utf-8')
 
1120
                         for k, v in viewitems(self._tree_path_ids)}
 
1121
        non_present_ids = {k: v.encode('utf-8')
 
1122
                           for k, v in viewitems(self._non_present_ids)}
 
1123
        removed_contents = [trans_id.encode('utf-8')
 
1124
                            for trans_id in self._removed_contents]
 
1125
        removed_id = [trans_id.encode('utf-8')
 
1126
                      for trans_id in self._removed_id]
1001
1127
        attribs = {
1002
 
            '_id_number': self._id_number,
1003
 
            '_new_name': new_name,
1004
 
            '_new_parent': self._new_parent,
1005
 
            '_new_executability': new_executability,
1006
 
            '_new_id': self._new_id,
1007
 
            '_tree_path_ids': tree_path_ids,
1008
 
            '_removed_id': list(self._removed_id),
1009
 
            '_removed_contents': list(self._removed_contents),
1010
 
            '_non_present_ids': self._non_present_ids,
 
1128
            b'_id_number': self._id_number,
 
1129
            b'_new_name': new_name,
 
1130
            b'_new_parent': new_parent,
 
1131
            b'_new_executability': new_executability,
 
1132
            b'_new_id': new_id,
 
1133
            b'_tree_path_ids': tree_path_ids,
 
1134
            b'_removed_id': removed_id,
 
1135
            b'_removed_contents': removed_contents,
 
1136
            b'_non_present_ids': non_present_ids,
1011
1137
            }
1012
1138
        yield serializer.bytes_record(bencode.bencode(attribs),
1013
 
                                      (('attribs',),))
1014
 
        for trans_id, kind in self._new_contents.items():
 
1139
                                      ((b'attribs',),))
 
1140
        for trans_id, kind in sorted(viewitems(self._new_contents)):
1015
1141
            if kind == 'file':
1016
 
                lines = osutils.chunks_to_lines(
1017
 
                    self._read_file_chunks(trans_id))
 
1142
                with open(self._limbo_name(trans_id), 'rb') as cur_file:
 
1143
                    lines = cur_file.readlines()
1018
1144
                parents = self._get_parents_lines(trans_id)
1019
1145
                mpdiff = multiparent.MultiParent.from_lines(lines, parents)
1020
 
                content = ''.join(mpdiff.to_patch())
 
1146
                content = b''.join(mpdiff.to_patch())
1021
1147
            if kind == 'directory':
1022
 
                content = ''
 
1148
                content = b''
1023
1149
            if kind == 'symlink':
1024
1150
                content = self._read_symlink_target(trans_id)
1025
 
            yield serializer.bytes_record(content, ((trans_id, kind),))
 
1151
                if not isinstance(content, bytes):
 
1152
                    content = content.encode('utf-8')
 
1153
            yield serializer.bytes_record(
 
1154
                content, ((trans_id.encode('utf-8'), kind.encode('ascii')),))
1026
1155
 
1027
1156
    def deserialize(self, records):
1028
1157
        """Deserialize a stored TreeTransform.
1030
1159
        :param records: An iterable of (names, content) tuples, as per
1031
1160
            pack.ContainerPushParser.
1032
1161
        """
1033
 
        names, content = records.next()
 
1162
        names, content = next(records)
1034
1163
        attribs = bencode.bdecode(content)
1035
 
        self._id_number = attribs['_id_number']
1036
 
        self._new_name = dict((k, v.decode('utf-8'))
1037
 
                            for k, v in attribs['_new_name'].items())
1038
 
        self._new_parent = attribs['_new_parent']
1039
 
        self._new_executability = dict((k, bool(v)) for k, v in
1040
 
            attribs['_new_executability'].items())
1041
 
        self._new_id = attribs['_new_id']
1042
 
        self._r_new_id = dict((v, k) for k, v in self._new_id.items())
 
1164
        self._id_number = attribs[b'_id_number']
 
1165
        self._new_name = {k.decode('utf-8'): v.decode('utf-8')
 
1166
                          for k, v in viewitems(attribs[b'_new_name'])}
 
1167
        self._new_parent = {k.decode('utf-8'): v.decode('utf-8')
 
1168
                            for k, v in viewitems(attribs[b'_new_parent'])}
 
1169
        self._new_executability = {
 
1170
            k.decode('utf-8'): bool(v)
 
1171
            for k, v in viewitems(attribs[b'_new_executability'])}
 
1172
        self._new_id = {k.decode('utf-8'): v
 
1173
                        for k, v in viewitems(attribs[b'_new_id'])}
 
1174
        self._r_new_id = {v: k for k, v in viewitems(self._new_id)}
1043
1175
        self._tree_path_ids = {}
1044
1176
        self._tree_id_paths = {}
1045
 
        for bytepath, trans_id in attribs['_tree_path_ids'].items():
 
1177
        for bytepath, trans_id in viewitems(attribs[b'_tree_path_ids']):
1046
1178
            path = bytepath.decode('utf-8')
 
1179
            trans_id = trans_id.decode('utf-8')
1047
1180
            self._tree_path_ids[path] = trans_id
1048
1181
            self._tree_id_paths[trans_id] = path
1049
 
        self._removed_id = set(attribs['_removed_id'])
1050
 
        self._removed_contents = set(attribs['_removed_contents'])
1051
 
        self._non_present_ids = attribs['_non_present_ids']
 
1182
        self._removed_id = {trans_id.decode('utf-8')
 
1183
                            for trans_id in attribs[b'_removed_id']}
 
1184
        self._removed_contents = set(
 
1185
            trans_id.decode('utf-8')
 
1186
            for trans_id in attribs[b'_removed_contents'])
 
1187
        self._non_present_ids = {
 
1188
            k: v.decode('utf-8')
 
1189
            for k, v in viewitems(attribs[b'_non_present_ids'])}
1052
1190
        for ((trans_id, kind),), content in records:
 
1191
            trans_id = trans_id.decode('utf-8')
 
1192
            kind = kind.decode('ascii')
1053
1193
            if kind == 'file':
1054
1194
                mpdiff = multiparent.MultiParent.from_patch(content)
1055
1195
                lines = mpdiff.to_lines(self._get_parents_texts(trans_id))
1063
1203
class DiskTreeTransform(TreeTransformBase):
1064
1204
    """Tree transform storing its contents on disk."""
1065
1205
 
1066
 
    def __init__(self, tree, limbodir, pb=None,
1067
 
                 case_sensitive=True):
 
1206
    def __init__(self, tree, limbodir, pb=None, case_sensitive=True):
1068
1207
        """Constructor.
1069
1208
        :param tree: The tree that will be transformed, but not necessarily
1070
1209
            the output tree.
1079
1218
        self._deletiondir = None
1080
1219
        # A mapping of transform ids to their limbo filename
1081
1220
        self._limbo_files = {}
 
1221
        self._possibly_stale_limbo_files = set()
1082
1222
        # A mapping of transform ids to a set of the transform ids of children
1083
1223
        # that their limbo directory has
1084
1224
        self._limbo_children = {}
1087
1227
        # List of transform ids that need to be renamed from limbo into place
1088
1228
        self._needs_rename = set()
1089
1229
        self._creation_mtime = None
 
1230
        self._create_symlinks = osutils.supports_symlinks(self._limbodir)
1090
1231
 
1091
1232
    def finalize(self):
1092
1233
        """Release the working tree lock, if held, clean up limbo dir.
1097
1238
        if self._tree is None:
1098
1239
            return
1099
1240
        try:
1100
 
            entries = [(self._limbo_name(t), t, k) for t, k in
1101
 
                       self._new_contents.iteritems()]
1102
 
            entries.sort(reverse=True)
1103
 
            for path, trans_id, kind in entries:
1104
 
                delete_any(path)
 
1241
            limbo_paths = list(viewvalues(self._limbo_files))
 
1242
            limbo_paths.extend(self._possibly_stale_limbo_files)
 
1243
            limbo_paths.sort(reverse=True)
 
1244
            for path in limbo_paths:
 
1245
                try:
 
1246
                    delete_any(path)
 
1247
                except OSError as e:
 
1248
                    if e.errno != errno.ENOENT:
 
1249
                        raise
 
1250
                    # XXX: warn? perhaps we just got interrupted at an
 
1251
                    # inconvenient moment, but perhaps files are disappearing
 
1252
                    # from under us?
1105
1253
            try:
1106
1254
                delete_any(self._limbodir)
1107
1255
            except OSError:
1115
1263
        finally:
1116
1264
            TreeTransformBase.finalize(self)
1117
1265
 
 
1266
    def _limbo_supports_executable(self):
 
1267
        """Check if the limbo path supports the executable bit."""
 
1268
        return osutils.supports_executable(self._limbodir)
 
1269
 
1118
1270
    def _limbo_name(self, trans_id):
1119
1271
        """Generate the limbo name of a file"""
1120
1272
        limbo_name = self._limbo_files.get(trans_id)
1136
1288
        previous_parent = self._new_parent.get(trans_id)
1137
1289
        previous_name = self._new_name.get(trans_id)
1138
1290
        TreeTransformBase.adjust_path(self, name, parent, trans_id)
1139
 
        if (trans_id in self._limbo_files and
1140
 
            trans_id not in self._needs_rename):
 
1291
        if (trans_id in self._limbo_files
 
1292
                and trans_id not in self._needs_rename):
1141
1293
            self._rename_in_limbo([trans_id])
1142
1294
            if previous_parent != parent:
1143
1295
                self._limbo_children[previous_parent].remove(trans_id)
1156
1308
        entries from _limbo_files, because they are now stale.
1157
1309
        """
1158
1310
        for trans_id in trans_ids:
1159
 
            old_path = self._limbo_files.pop(trans_id)
 
1311
            old_path = self._limbo_files[trans_id]
 
1312
            self._possibly_stale_limbo_files.add(old_path)
 
1313
            del self._limbo_files[trans_id]
1160
1314
            if trans_id not in self._new_contents:
1161
1315
                continue
1162
1316
            new_path = self._limbo_name(trans_id)
1163
 
            osutils.rename(old_path, new_path)
 
1317
            os.rename(old_path, new_path)
 
1318
            self._possibly_stale_limbo_files.remove(old_path)
1164
1319
            for descendant in self._limbo_descendants(trans_id):
1165
1320
                desc_path = self._limbo_files[descendant]
1166
1321
                desc_path = new_path + desc_path[len(old_path):]
1173
1328
            descendants.update(self._limbo_descendants(descendant))
1174
1329
        return descendants
1175
1330
 
1176
 
    def create_file(self, contents, trans_id, mode_id=None):
 
1331
    def create_file(self, contents, trans_id, mode_id=None, sha1=None):
1177
1332
        """Schedule creation of a new file.
1178
1333
 
1179
 
        See also new_file.
1180
 
 
1181
 
        Contents is an iterator of strings, all of which will be written
1182
 
        to the target destination.
1183
 
 
1184
 
        New file takes the permissions of any existing file with that id,
1185
 
        unless mode_id is specified.
 
1334
        :seealso: new_file.
 
1335
 
 
1336
        :param contents: an iterator of strings, all of which will be written
 
1337
            to the target destination.
 
1338
        :param trans_id: TreeTransform handle
 
1339
        :param mode_id: If not None, force the mode of the target file to match
 
1340
            the mode of the object referenced by mode_id.
 
1341
            Otherwise, we will try to preserve mode bits of an existing file.
 
1342
        :param sha1: If the sha1 of this content is already known, pass it in.
 
1343
            We can use it to prevent future sha1 computations.
1186
1344
        """
1187
1345
        name = self._limbo_name(trans_id)
1188
 
        f = open(name, 'wb')
1189
 
        try:
1190
 
            try:
1191
 
                unique_add(self._new_contents, trans_id, 'file')
1192
 
            except:
1193
 
                # Clean up the file, it never got registered so
1194
 
                # TreeTransform.finalize() won't clean it up.
1195
 
                f.close()
1196
 
                os.unlink(name)
1197
 
                raise
1198
 
 
 
1346
        with open(name, 'wb') as f:
 
1347
            unique_add(self._new_contents, trans_id, 'file')
1199
1348
            f.writelines(contents)
1200
 
        finally:
1201
 
            f.close()
1202
1349
        self._set_mtime(name)
1203
1350
        self._set_mode(trans_id, mode_id, S_ISREG)
1204
 
 
1205
 
    def _read_file_chunks(self, trans_id):
1206
 
        cur_file = open(self._limbo_name(trans_id), 'rb')
1207
 
        try:
1208
 
            return cur_file.readlines()
1209
 
        finally:
1210
 
            cur_file.close()
 
1351
        # It is unfortunate we have to use lstat instead of fstat, but we just
 
1352
        # used utime and chmod on the file, so we need the accurate final
 
1353
        # details.
 
1354
        if sha1 is not None:
 
1355
            self._observed_sha1s[trans_id] = (sha1, osutils.lstat(name))
1211
1356
 
1212
1357
    def _read_symlink_target(self, trans_id):
1213
1358
        return os.readlink(self._limbo_name(trans_id))
1226
1371
        name = self._limbo_name(trans_id)
1227
1372
        try:
1228
1373
            os.link(path, name)
1229
 
        except OSError, e:
 
1374
        except OSError as e:
1230
1375
            if e.errno != errno.EPERM:
1231
1376
                raise
1232
1377
            raise errors.HardLinkNotSupported(path)
1233
1378
        try:
1234
1379
            unique_add(self._new_contents, trans_id, 'file')
1235
 
        except:
 
1380
        except BaseException:
1236
1381
            # Clean up the file, it never got registered so
1237
1382
            # TreeTransform.finalize() won't clean it up.
1238
1383
            os.unlink(name)
1252
1397
        target is a bytestring.
1253
1398
        See also new_symlink.
1254
1399
        """
1255
 
        if has_symlinks():
 
1400
        if self._create_symlinks:
1256
1401
            os.symlink(target, self._limbo_name(trans_id))
1257
 
            unique_add(self._new_contents, trans_id, 'symlink')
1258
1402
        else:
1259
1403
            try:
1260
1404
                path = FinalPaths(self).get_path(trans_id)
1261
1405
            except KeyError:
1262
1406
                path = None
1263
 
            raise UnableCreateSymlink(path=path)
 
1407
            trace.warning(
 
1408
                'Unable to create symlink "%s" on this filesystem.' % (path,))
 
1409
        # We add symlink to _new_contents even if they are unsupported
 
1410
        # and not created. These entries are subsequently used to avoid
 
1411
        # conflicts on platforms that don't support symlink
 
1412
        unique_add(self._new_contents, trans_id, 'symlink')
1264
1413
 
1265
1414
    def cancel_creation(self, trans_id):
1266
1415
        """Cancel the creation of new file contents."""
1267
1416
        del self._new_contents[trans_id]
 
1417
        if trans_id in self._observed_sha1s:
 
1418
            del self._observed_sha1s[trans_id]
1268
1419
        children = self._limbo_children.get(trans_id)
1269
1420
        # if this is a limbo directory with children, move them before removing
1270
1421
        # the directory
1274
1425
            del self._limbo_children_names[trans_id]
1275
1426
        delete_any(self._limbo_name(trans_id))
1276
1427
 
 
1428
    def new_orphan(self, trans_id, parent_id):
 
1429
        conf = self._tree.get_config_stack()
 
1430
        handle_orphan = conf.get('transform.orphan_policy')
 
1431
        handle_orphan(self, trans_id, parent_id)
 
1432
 
 
1433
 
 
1434
class OrphaningError(errors.BzrError):
 
1435
 
 
1436
    # Only bugs could lead to such exception being seen by the user
 
1437
    internal_error = True
 
1438
    _fmt = "Error while orphaning %s in %s directory"
 
1439
 
 
1440
    def __init__(self, orphan, parent):
 
1441
        errors.BzrError.__init__(self)
 
1442
        self.orphan = orphan
 
1443
        self.parent = parent
 
1444
 
 
1445
 
 
1446
class OrphaningForbidden(OrphaningError):
 
1447
 
 
1448
    _fmt = "Policy: %s doesn't allow creating orphans."
 
1449
 
 
1450
    def __init__(self, policy):
 
1451
        errors.BzrError.__init__(self)
 
1452
        self.policy = policy
 
1453
 
 
1454
 
 
1455
def move_orphan(tt, orphan_id, parent_id):
 
1456
    """See TreeTransformBase.new_orphan.
 
1457
 
 
1458
    This creates a new orphan in the `brz-orphans` dir at the root of the
 
1459
    `TreeTransform`.
 
1460
 
 
1461
    :param tt: The TreeTransform orphaning `trans_id`.
 
1462
 
 
1463
    :param orphan_id: The trans id that should be orphaned.
 
1464
 
 
1465
    :param parent_id: The orphan parent trans id.
 
1466
    """
 
1467
    # Add the orphan dir if it doesn't exist
 
1468
    orphan_dir_basename = 'brz-orphans'
 
1469
    od_id = tt.trans_id_tree_path(orphan_dir_basename)
 
1470
    if tt.final_kind(od_id) is None:
 
1471
        tt.create_directory(od_id)
 
1472
    parent_path = tt._tree_id_paths[parent_id]
 
1473
    # Find a name that doesn't exist yet in the orphan dir
 
1474
    actual_name = tt.final_name(orphan_id)
 
1475
    new_name = tt._available_backup_name(actual_name, od_id)
 
1476
    tt.adjust_path(new_name, od_id, orphan_id)
 
1477
    trace.warning('%s has been orphaned in %s'
 
1478
                  % (joinpath(parent_path, actual_name), orphan_dir_basename))
 
1479
 
 
1480
 
 
1481
def refuse_orphan(tt, orphan_id, parent_id):
 
1482
    """See TreeTransformBase.new_orphan.
 
1483
 
 
1484
    This refuses to create orphan, letting the caller handle the conflict.
 
1485
    """
 
1486
    raise OrphaningForbidden('never')
 
1487
 
 
1488
 
 
1489
orphaning_registry = registry.Registry()
 
1490
orphaning_registry.register(
 
1491
    u'conflict', refuse_orphan,
 
1492
    'Leave orphans in place and create a conflict on the directory.')
 
1493
orphaning_registry.register(
 
1494
    u'move', move_orphan,
 
1495
    'Move orphans into the brz-orphans directory.')
 
1496
orphaning_registry._set_default_key(u'conflict')
 
1497
 
 
1498
 
 
1499
opt_transform_orphan = _mod_config.RegistryOption(
 
1500
    'transform.orphan_policy', orphaning_registry,
 
1501
    help='Policy for orphaned files during transform operations.',
 
1502
    invalid='warning')
 
1503
 
1277
1504
 
1278
1505
class TreeTransform(DiskTreeTransform):
1279
1506
    """Represent a tree transformation.
1340
1567
    FileMover does not delete files until it is sure that a rollback will not
1341
1568
    happen.
1342
1569
    """
 
1570
 
1343
1571
    def __init__(self, tree, pb=None):
1344
1572
        """Note: a tree_write lock is taken on the tree.
1345
1573
 
1347
1575
        TreeTransform.apply() called).
1348
1576
        """
1349
1577
        tree.lock_tree_write()
1350
 
 
1351
1578
        try:
1352
1579
            limbodir = urlutils.local_path_from_url(
1353
1580
                tree._transport.abspath('limbo'))
1354
 
            try:
1355
 
                os.mkdir(limbodir)
1356
 
            except OSError, e:
1357
 
                if e.errno == errno.EEXIST:
1358
 
                    raise ExistingLimbo(limbodir)
 
1581
            osutils.ensure_empty_directory_exists(
 
1582
                limbodir,
 
1583
                errors.ExistingLimbo)
1359
1584
            deletiondir = urlutils.local_path_from_url(
1360
1585
                tree._transport.abspath('pending-deletion'))
1361
 
            try:
1362
 
                os.mkdir(deletiondir)
1363
 
            except OSError, e:
1364
 
                if e.errno == errno.EEXIST:
1365
 
                    raise errors.ExistingPendingDeletion(deletiondir)
1366
 
        except:
 
1586
            osutils.ensure_empty_directory_exists(
 
1587
                deletiondir,
 
1588
                errors.ExistingPendingDeletion)
 
1589
        except BaseException:
1367
1590
            tree.unlock()
1368
1591
            raise
1369
1592
 
1397
1620
    def tree_kind(self, trans_id):
1398
1621
        """Determine the file kind in the working tree.
1399
1622
 
1400
 
        Raises NoSuchFile if the file does not exist
 
1623
        :returns: The file kind or None if the file does not exist
1401
1624
        """
1402
1625
        path = self._tree_id_paths.get(trans_id)
1403
1626
        if path is None:
1404
 
            raise NoSuchFile(None)
 
1627
            return None
1405
1628
        try:
1406
1629
            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)
 
1630
        except errors.NoSuchFile:
 
1631
            return None
1412
1632
 
1413
1633
    def _set_mode(self, trans_id, mode_id, typefunc):
1414
1634
        """Set the mode of new file contents.
1424
1644
            return
1425
1645
        try:
1426
1646
            mode = os.stat(self._tree.abspath(old_path)).st_mode
1427
 
        except OSError, e:
 
1647
        except OSError as e:
1428
1648
            if e.errno in (errno.ENOENT, errno.ENOTDIR):
1429
1649
                # Either old_path doesn't exist, or the parent of the
1430
1650
                # target is not a directory (but will be one eventually)
1434
1654
            else:
1435
1655
                raise
1436
1656
        if typefunc(mode):
1437
 
            os.chmod(self._limbo_name(trans_id), mode)
 
1657
            osutils.chmod_if_possible(self._limbo_name(trans_id), mode)
1438
1658
 
1439
1659
    def iter_tree_children(self, parent_id):
1440
1660
        """Iterate through the entry's tree children, if any"""
1444
1664
            return
1445
1665
        try:
1446
1666
            children = os.listdir(self._tree.abspath(path))
1447
 
        except OSError, e:
1448
 
            if not (osutils._is_error_enotdir(e)
1449
 
                    or e.errno in (errno.ENOENT, errno.ESRCH)):
 
1667
        except OSError as e:
 
1668
            if not (osutils._is_error_enotdir(e) or
 
1669
                    e.errno in (errno.ENOENT, errno.ESRCH)):
1450
1670
                raise
1451
1671
            return
1452
1672
 
1483
1703
                # if it is already associated with this trans_id.
1484
1704
                elif self._case_sensitive_target:
1485
1705
                    if (self._limbo_children_names[parent].get(filename)
1486
 
                        in (trans_id, None)):
 
1706
                            in (trans_id, None)):
1487
1707
                        use_direct_path = True
1488
1708
                else:
1489
 
                    for l_filename, l_trans_id in\
1490
 
                        self._limbo_children_names[parent].iteritems():
 
1709
                    for l_filename, l_trans_id in viewitems(
 
1710
                            self._limbo_children_names[parent]):
1491
1711
                        if l_trans_id == trans_id:
1492
1712
                            continue
1493
1713
                        if l_filename.lower() == filename.lower():
1503
1723
        self._limbo_children_names[parent][filename] = trans_id
1504
1724
        return limbo_name
1505
1725
 
1506
 
 
1507
1726
    def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
1508
1727
        """Apply all changes to the inventory and filesystem.
1509
1728
 
1518
1737
            calculating one.
1519
1738
        :param _mover: Supply an alternate FileMover, for testing
1520
1739
        """
 
1740
        for hook in MutableTree.hooks['pre_transform']:
 
1741
            hook(self._tree, self)
1521
1742
        if not no_conflicts:
1522
1743
            self._check_malformed()
1523
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1524
 
        try:
 
1744
        with ui.ui_factory.nested_progress_bar() as child_pb:
1525
1745
            if precomputed_delta is None:
1526
 
                child_pb.update('Apply phase', 0, 2)
 
1746
                child_pb.update(gettext('Apply phase'), 0, 2)
1527
1747
                inventory_delta = self._generate_inventory_delta()
1528
1748
                offset = 1
1529
1749
            else:
1534
1754
            else:
1535
1755
                mover = _mover
1536
1756
            try:
1537
 
                child_pb.update('Apply phase', 0 + offset, 2 + offset)
 
1757
                child_pb.update(gettext('Apply phase'), 0 + offset, 2 + offset)
1538
1758
                self._apply_removals(mover)
1539
 
                child_pb.update('Apply phase', 1 + offset, 2 + offset)
 
1759
                child_pb.update(gettext('Apply phase'), 1 + offset, 2 + offset)
1540
1760
                modified_paths = self._apply_insertions(mover)
1541
 
            except:
 
1761
            except BaseException:
1542
1762
                mover.rollback()
1543
1763
                raise
1544
1764
            else:
1545
1765
                mover.apply_deletions()
1546
 
        finally:
1547
 
            child_pb.finished()
 
1766
        if self.final_file_id(self.root) is None:
 
1767
            inventory_delta = [e for e in inventory_delta if e[0] != '']
1548
1768
        self._tree.apply_inventory_delta(inventory_delta)
 
1769
        self._apply_observed_sha1s()
1549
1770
        self._done = True
1550
1771
        self.finalize()
1551
1772
        return _TransformResults(modified_paths, self.rename_count)
1553
1774
    def _generate_inventory_delta(self):
1554
1775
        """Generate an inventory delta for the current transform."""
1555
1776
        inventory_delta = []
1556
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1557
1777
        new_paths = self._inventory_altered()
1558
1778
        total_entries = len(new_paths) + len(self._removed_id)
1559
 
        try:
 
1779
        with ui.ui_factory.nested_progress_bar() as child_pb:
1560
1780
            for num, trans_id in enumerate(self._removed_id):
1561
1781
                if (num % 10) == 0:
1562
 
                    child_pb.update('removing file', num, total_entries)
 
1782
                    child_pb.update(gettext('removing file'),
 
1783
                                    num, total_entries)
1563
1784
                if trans_id == self._new_root:
1564
1785
                    file_id = self._tree.get_root_id()
1565
1786
                else:
1571
1792
                inventory_delta.append((path, None, file_id, None))
1572
1793
            new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1573
1794
                                     new_paths)
1574
 
            entries = self._tree.iter_entries_by_dir(
1575
 
                new_path_file_ids.values())
1576
 
            old_paths = dict((e.file_id, p) for p, e in entries)
1577
 
            final_kinds = {}
1578
1795
            for num, (path, trans_id) in enumerate(new_paths):
1579
1796
                if (num % 10) == 0:
1580
 
                    child_pb.update('adding file',
 
1797
                    child_pb.update(gettext('adding file'),
1581
1798
                                    num + len(self._removed_id), total_entries)
1582
1799
                file_id = new_path_file_ids[trans_id]
1583
1800
                if file_id is None:
1584
1801
                    continue
1585
 
                needs_entry = False
1586
 
                try:
1587
 
                    kind = self.final_kind(trans_id)
1588
 
                except NoSuchFile:
1589
 
                    kind = self._tree.stored_kind(file_id)
 
1802
                kind = self.final_kind(trans_id)
 
1803
                if kind is None:
 
1804
                    kind = self._tree.stored_kind(self._tree.id2path(file_id))
1590
1805
                parent_trans_id = self.final_parent(trans_id)
1591
1806
                parent_file_id = new_path_file_ids.get(parent_trans_id)
1592
1807
                if parent_file_id is None:
1599
1814
                        None, self._new_reference_revision[trans_id])
1600
1815
                else:
1601
1816
                    new_entry = inventory.make_entry(kind,
1602
 
                        self.final_name(trans_id),
1603
 
                        parent_file_id, file_id)
1604
 
                old_path = old_paths.get(new_entry.file_id)
 
1817
                                                     self.final_name(trans_id),
 
1818
                                                     parent_file_id, file_id)
 
1819
                try:
 
1820
                    old_path = self._tree.id2path(new_entry.file_id)
 
1821
                except errors.NoSuchId:
 
1822
                    old_path = None
1605
1823
                new_executability = self._new_executability.get(trans_id)
1606
1824
                if new_executability is not None:
1607
1825
                    new_entry.executable = new_executability
1608
1826
                inventory_delta.append(
1609
1827
                    (old_path, path, new_entry.file_id, new_entry))
1610
 
        finally:
1611
 
            child_pb.finished()
1612
1828
        return inventory_delta
1613
1829
 
1614
1830
    def _apply_removals(self, mover):
1620
1836
 
1621
1837
        If inventory_delta is None, no inventory delta generation is performed.
1622
1838
        """
1623
 
        tree_paths = list(self._tree_path_ids.iteritems())
1624
 
        tree_paths.sort(reverse=True)
1625
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1626
 
        try:
1627
 
            for num, data in enumerate(tree_paths):
1628
 
                path, trans_id = data
1629
 
                child_pb.update('removing file', num, len(tree_paths))
 
1839
        tree_paths = sorted(viewitems(self._tree_path_ids), reverse=True)
 
1840
        with ui.ui_factory.nested_progress_bar() as child_pb:
 
1841
            for num, (path, trans_id) in enumerate(tree_paths):
 
1842
                # do not attempt to move root into a subdirectory of itself.
 
1843
                if path == '':
 
1844
                    continue
 
1845
                child_pb.update(gettext('removing file'), num, len(tree_paths))
1630
1846
                full_path = self._tree.abspath(path)
1631
1847
                if trans_id in self._removed_contents:
1632
1848
                    delete_path = os.path.join(self._deletiondir, trans_id)
1633
1849
                    mover.pre_delete(full_path, delete_path)
1634
 
                elif (trans_id in self._new_name
1635
 
                      or trans_id in self._new_parent):
 
1850
                elif (trans_id in self._new_name or
 
1851
                      trans_id in self._new_parent):
1636
1852
                    try:
1637
1853
                        mover.rename(full_path, self._limbo_name(trans_id))
1638
 
                    except OSError, e:
 
1854
                    except errors.TransformRenameFailed as e:
1639
1855
                        if e.errno != errno.ENOENT:
1640
1856
                            raise
1641
1857
                    else:
1642
1858
                        self.rename_count += 1
1643
 
        finally:
1644
 
            child_pb.finished()
1645
1859
 
1646
1860
    def _apply_insertions(self, mover):
1647
1861
        """Perform tree operations that insert directory/inventory names.
1655
1869
        """
1656
1870
        new_paths = self.new_paths(filesystem_only=True)
1657
1871
        modified_paths = []
1658
 
        new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1659
 
                                 new_paths)
1660
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1661
 
        try:
 
1872
        with ui.ui_factory.nested_progress_bar() as child_pb:
1662
1873
            for num, (path, trans_id) in enumerate(new_paths):
1663
1874
                if (num % 10) == 0:
1664
 
                    child_pb.update('adding file', num, len(new_paths))
 
1875
                    child_pb.update(gettext('adding file'),
 
1876
                                    num, len(new_paths))
1665
1877
                full_path = self._tree.abspath(path)
1666
1878
                if trans_id in self._needs_rename:
1667
1879
                    try:
1668
1880
                        mover.rename(self._limbo_name(trans_id), full_path)
1669
 
                    except OSError, e:
 
1881
                    except errors.TransformRenameFailed as e:
1670
1882
                        # We may be renaming a dangling inventory id
1671
1883
                        if e.errno != errno.ENOENT:
1672
1884
                            raise
1673
1885
                    else:
1674
1886
                        self.rename_count += 1
1675
 
                if (trans_id in self._new_contents or
1676
 
                    self.path_changed(trans_id)):
 
1887
                    # TODO: if trans_id in self._observed_sha1s, we should
 
1888
                    #       re-stat the final target, since ctime will be
 
1889
                    #       updated by the change.
 
1890
                if (trans_id in self._new_contents
 
1891
                        or self.path_changed(trans_id)):
1677
1892
                    if trans_id in self._new_contents:
1678
1893
                        modified_paths.append(full_path)
1679
1894
                if trans_id in self._new_executability:
1680
1895
                    self._set_executability(path, trans_id)
1681
 
        finally:
1682
 
            child_pb.finished()
 
1896
                if trans_id in self._observed_sha1s:
 
1897
                    o_sha1, o_st_val = self._observed_sha1s[trans_id]
 
1898
                    st = osutils.lstat(full_path)
 
1899
                    self._observed_sha1s[trans_id] = (o_sha1, st)
 
1900
        for path, trans_id in new_paths:
 
1901
            # new_paths includes stuff like workingtree conflicts. Only the
 
1902
            # stuff in new_contents actually comes from limbo.
 
1903
            if trans_id in self._limbo_files:
 
1904
                del self._limbo_files[trans_id]
1683
1905
        self._new_contents.clear()
1684
1906
        return modified_paths
1685
1907
 
 
1908
    def _apply_observed_sha1s(self):
 
1909
        """After we have finished renaming everything, update observed sha1s
 
1910
 
 
1911
        This has to be done after self._tree.apply_inventory_delta, otherwise
 
1912
        it doesn't know anything about the files we are updating. Also, we want
 
1913
        to do this as late as possible, so that most entries end up cached.
 
1914
        """
 
1915
        # TODO: this doesn't update the stat information for directories. So
 
1916
        #       the first 'bzr status' will still need to rewrite
 
1917
        #       .bzr/checkout/dirstate. However, we at least don't need to
 
1918
        #       re-read all of the files.
 
1919
        # TODO: If the operation took a while, we could do a time.sleep(3) here
 
1920
        #       to allow the clock to tick over and ensure we won't have any
 
1921
        #       problems. (we could observe start time, and finish time, and if
 
1922
        #       it is less than eg 10% overhead, add a sleep call.)
 
1923
        paths = FinalPaths(self)
 
1924
        for trans_id, observed in viewitems(self._observed_sha1s):
 
1925
            path = paths.get_path(trans_id)
 
1926
            self._tree._observed_sha1(path, observed)
 
1927
 
1686
1928
 
1687
1929
class TransformPreview(DiskTreeTransform):
1688
1930
    """A TreeTransform for generating preview trees.
1703
1945
    def tree_kind(self, trans_id):
1704
1946
        path = self._tree_id_paths.get(trans_id)
1705
1947
        if path is None:
1706
 
            raise NoSuchFile(None)
1707
 
        file_id = self._tree.path2id(path)
1708
 
        return self._tree.kind(file_id)
 
1948
            return None
 
1949
        kind = self._tree.path_content_summary(path)[0]
 
1950
        if kind == 'missing':
 
1951
            kind = None
 
1952
        return kind
1709
1953
 
1710
1954
    def _set_mode(self, trans_id, mode_id, typefunc):
1711
1955
        """Set the mode of new file contents.
1722
1966
            path = self._tree_id_paths[parent_id]
1723
1967
        except KeyError:
1724
1968
            return
1725
 
        file_id = self.tree_file_id(parent_id)
1726
 
        if file_id is None:
 
1969
        try:
 
1970
            entry = next(self._tree.iter_entries_by_dir(
 
1971
                specific_files=[path]))[1]
 
1972
        except StopIteration:
1727
1973
            return
1728
 
        entry = self._tree.iter_entries_by_dir([file_id]).next()[1]
1729
1974
        children = getattr(entry, 'children', {})
1730
1975
        for child in children:
1731
1976
            childpath = joinpath(path, child)
1732
1977
            yield self.trans_id_tree_path(childpath)
1733
1978
 
1734
 
 
1735
 
class _PreviewTree(tree.Tree):
 
1979
    def new_orphan(self, trans_id, parent_id):
 
1980
        raise NotImplementedError(self.new_orphan)
 
1981
 
 
1982
 
 
1983
class _PreviewTree(inventorytree.InventoryTree):
1736
1984
    """Partial implementation of Tree to support show_diff_trees"""
1737
1985
 
1738
1986
    def __init__(self, transform):
1766
2014
            except errors.NoSuchRevisionInTree:
1767
2015
                yield self._get_repository().revision_tree(revision_id)
1768
2016
 
1769
 
    def _get_file_revision(self, file_id, vf, tree_revision):
1770
 
        parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
1771
 
                       self._iter_parent_trees()]
 
2017
    def _get_file_revision(self, path, file_id, vf, tree_revision):
 
2018
        parent_keys = [
 
2019
            (file_id, t.get_file_revision(t.id2path(file_id)))
 
2020
            for t in self._iter_parent_trees()]
1772
2021
        vf.add_lines((file_id, tree_revision), parent_keys,
1773
 
                     self.get_file(file_id).readlines())
 
2022
                     self.get_file_lines(path))
1774
2023
        repo = self._get_repository()
1775
2024
        base_vf = repo.texts
1776
2025
        if base_vf not in vf.fallback_versionedfiles:
1777
2026
            vf.fallback_versionedfiles.append(base_vf)
1778
2027
        return tree_revision
1779
2028
 
1780
 
    def _stat_limbo_file(self, file_id):
1781
 
        trans_id = self._transform.trans_id_file_id(file_id)
 
2029
    def _stat_limbo_file(self, trans_id):
1782
2030
        name = self._transform._limbo_name(trans_id)
1783
2031
        return os.lstat(name)
1784
2032
 
1795
2043
            executable = False
1796
2044
        else:
1797
2045
            file_id = self._transform.final_file_id(self._path2trans_id(path))
1798
 
            executable = self.is_executable(file_id, path)
 
2046
            executable = self.is_executable(path)
1799
2047
        return kind, executable, None
1800
2048
 
 
2049
    def is_locked(self):
 
2050
        return False
 
2051
 
1801
2052
    def lock_read(self):
1802
2053
        # Perhaps in theory, this should lock the TreeTransform?
1803
 
        pass
 
2054
        return lock.LogicalLockResult(self.unlock)
1804
2055
 
1805
2056
    def unlock(self):
1806
2057
        pass
1807
2058
 
1808
2059
    @property
1809
 
    def inventory(self):
 
2060
    def root_inventory(self):
1810
2061
        """This Tree does not use inventory as its backing data."""
1811
 
        raise NotImplementedError(_PreviewTree.inventory)
 
2062
        raise NotImplementedError(_PreviewTree.root_inventory)
1812
2063
 
1813
2064
    def get_root_id(self):
1814
2065
        return self._transform.final_file_id(self._transform.root)
1817
2068
        tree_ids = set(self._transform._tree.all_file_ids())
1818
2069
        tree_ids.difference_update(self._transform.tree_file_id(t)
1819
2070
                                   for t in self._transform._removed_id)
1820
 
        tree_ids.update(self._transform._new_id.values())
 
2071
        tree_ids.update(viewvalues(self._transform._new_id))
1821
2072
        return tree_ids
1822
2073
 
1823
 
    def __iter__(self):
1824
 
        return iter(self.all_file_ids())
 
2074
    def all_versioned_paths(self):
 
2075
        tree_paths = set(self._transform._tree.all_versioned_paths())
 
2076
 
 
2077
        tree_paths.difference_update(
 
2078
            self._transform.trans_id_tree_path(t)
 
2079
            for t in self._transform._removed_id)
 
2080
 
 
2081
        tree_paths.update(
 
2082
            self._final_paths._determine_path(t)
 
2083
            for t in self._transform._new_id)
 
2084
 
 
2085
        return tree_paths
1825
2086
 
1826
2087
    def _has_id(self, file_id, fallback_check):
1827
2088
        if file_id in self._transform._r_new_id:
1828
2089
            return True
1829
 
        elif file_id in set([self._transform.tree_file_id(trans_id) for
1830
 
            trans_id in self._transform._removed_id]):
 
2090
        elif file_id in {self._transform.tree_file_id(trans_id) for
 
2091
                         trans_id in self._transform._removed_id}:
1831
2092
            return False
1832
2093
        else:
1833
2094
            return fallback_check(file_id)
1861
2122
        return cur_parent
1862
2123
 
1863
2124
    def path2id(self, path):
 
2125
        if isinstance(path, list):
 
2126
            if path == []:
 
2127
                path = [""]
 
2128
            path = osutils.pathjoin(*path)
1864
2129
        return self._transform.final_file_id(self._path2trans_id(path))
1865
2130
 
1866
2131
    def id2path(self, file_id):
1876
2141
            return children
1877
2142
        children = set(self._transform.iter_tree_children(trans_id))
1878
2143
        # children in the _new_parent set are provided by _by_parent.
1879
 
        children.difference_update(self._transform._new_parent.keys())
 
2144
        children.difference_update(self._transform._new_parent)
1880
2145
        children.update(self._by_parent.get(trans_id, []))
1881
2146
        self._all_children_cache[trans_id] = children
1882
2147
        return children
1883
2148
 
1884
 
    def iter_children(self, file_id):
 
2149
    def _iter_children(self, file_id):
1885
2150
        trans_id = self._transform.trans_id_file_id(file_id)
1886
2151
        for child_trans_id in self._all_children(trans_id):
1887
2152
            yield self._transform.final_file_id(child_trans_id)
1895
2160
            if self._transform.final_file_id(trans_id) is None:
1896
2161
                yield self._final_paths._determine_path(trans_id)
1897
2162
 
1898
 
    def _make_inv_entries(self, ordered_entries, specific_file_ids=None,
1899
 
        yield_parents=False):
 
2163
    def _make_inv_entries(self, ordered_entries, specific_files=None):
1900
2164
        for trans_id, parent_file_id in ordered_entries:
1901
2165
            file_id = self._transform.final_file_id(trans_id)
1902
2166
            if file_id is None:
1903
2167
                continue
1904
 
            if (specific_file_ids is not None
1905
 
                and file_id not in specific_file_ids):
 
2168
            if (specific_files is not None
 
2169
                    and self._final_paths.get_path(trans_id) not in specific_files):
1906
2170
                continue
1907
 
            try:
1908
 
                kind = self._transform.final_kind(trans_id)
1909
 
            except NoSuchFile:
1910
 
                kind = self._transform._tree.stored_kind(file_id)
 
2171
            kind = self._transform.final_kind(trans_id)
 
2172
            if kind is None:
 
2173
                kind = self._transform._tree.stored_kind(
 
2174
                    self._transform._tree.id2path(file_id))
1911
2175
            new_entry = inventory.make_entry(
1912
2176
                kind,
1913
2177
                self._transform.final_name(trans_id),
1928
2192
                ordered_ids.append((trans_id, parent_file_id))
1929
2193
        return ordered_ids
1930
2194
 
1931
 
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
 
2195
    def iter_child_entries(self, path):
 
2196
        trans_id = self._path2trans_id(path)
 
2197
        if trans_id is None:
 
2198
            raise errors.NoSuchFile(path)
 
2199
        todo = [(child_trans_id, trans_id) for child_trans_id in
 
2200
                self._all_children(trans_id)]
 
2201
        for entry, trans_id in self._make_inv_entries(todo):
 
2202
            yield entry
 
2203
 
 
2204
    def iter_entries_by_dir(self, specific_files=None):
1932
2205
        # This may not be a maximally efficient implementation, but it is
1933
2206
        # reasonably straightforward.  An implementation that grafts the
1934
2207
        # TreeTransform changes onto the tree's iter_entries_by_dir results
1936
2209
        # position.
1937
2210
        ordered_ids = self._list_files_by_dir()
1938
2211
        for entry, trans_id in self._make_inv_entries(ordered_ids,
1939
 
            specific_file_ids, yield_parents=yield_parents):
1940
 
            yield unicode(self._final_paths.get_path(trans_id)), entry
 
2212
                                                      specific_files):
 
2213
            yield self._final_paths.get_path(trans_id), entry
1941
2214
 
1942
2215
    def _iter_entries_for_dir(self, dir_path):
1943
2216
        """Return path, entry for items in a directory without recursing down."""
1944
 
        dir_file_id = self.path2id(dir_path)
1945
2217
        ordered_ids = []
1946
 
        for file_id in self.iter_children(dir_file_id):
1947
 
            trans_id = self._transform.trans_id_file_id(file_id)
1948
 
            ordered_ids.append((trans_id, file_id))
 
2218
        dir_trans_id = self._path2trans_id(dir_path)
 
2219
        dir_id = self._transform.final_file_id(dir_trans_id)
 
2220
        for child_trans_id in self._all_children(dir_trans_id):
 
2221
            ordered_ids.append((child_trans_id, dir_id))
 
2222
        path_entries = []
1949
2223
        for entry, trans_id in self._make_inv_entries(ordered_ids):
1950
 
            yield unicode(self._final_paths.get_path(trans_id)), entry
 
2224
            path_entries.append((self._final_paths.get_path(trans_id), entry))
 
2225
        path_entries.sort()
 
2226
        return path_entries
1951
2227
 
1952
2228
    def list_files(self, include_root=False, from_dir=None, recursive=True):
1953
2229
        """See WorkingTree.list_files."""
1954
2230
        # XXX This should behave like WorkingTree.list_files, but is really
1955
2231
        # more like RevisionTree.list_files.
 
2232
        if from_dir == '.':
 
2233
            from_dir = None
1956
2234
        if recursive:
1957
2235
            prefix = None
1958
2236
            if from_dir:
1965
2243
                    if not path.startswith(prefix):
1966
2244
                        continue
1967
2245
                    path = path[len(prefix):]
1968
 
                yield path, 'V', entry.kind, entry.file_id, entry
 
2246
                yield path, 'V', entry.kind, entry
1969
2247
        else:
1970
2248
            if from_dir is None and include_root is True:
1971
 
                root_entry = inventory.make_entry('directory', '',
1972
 
                    ROOT_PARENT, self.get_root_id())
1973
 
                yield '', 'V', 'directory', root_entry.file_id, root_entry
 
2249
                root_entry = inventory.make_entry(
 
2250
                    'directory', '', ROOT_PARENT, self.get_root_id())
 
2251
                yield '', 'V', 'directory', root_entry
1974
2252
            entries = self._iter_entries_for_dir(from_dir or '')
1975
2253
            for path, entry in entries:
1976
 
                yield path, 'V', entry.kind, entry.file_id, entry
 
2254
                yield path, 'V', entry.kind, entry
1977
2255
 
1978
 
    def kind(self, file_id):
1979
 
        trans_id = self._transform.trans_id_file_id(file_id)
 
2256
    def kind(self, path):
 
2257
        trans_id = self._path2trans_id(path)
 
2258
        if trans_id is None:
 
2259
            raise errors.NoSuchFile(path)
1980
2260
        return self._transform.final_kind(trans_id)
1981
2261
 
1982
 
    def stored_kind(self, file_id):
1983
 
        trans_id = self._transform.trans_id_file_id(file_id)
 
2262
    def stored_kind(self, path):
 
2263
        trans_id = self._path2trans_id(path)
 
2264
        if trans_id is None:
 
2265
            raise errors.NoSuchFile(path)
1984
2266
        try:
1985
2267
            return self._transform._new_contents[trans_id]
1986
2268
        except KeyError:
1987
 
            return self._transform._tree.stored_kind(file_id)
 
2269
            return self._transform._tree.stored_kind(path)
1988
2270
 
1989
 
    def get_file_mtime(self, file_id, path=None):
 
2271
    def get_file_mtime(self, path):
1990
2272
        """See Tree.get_file_mtime"""
 
2273
        file_id = self.path2id(path)
 
2274
        if file_id is None:
 
2275
            raise errors.NoSuchFile(path)
1991
2276
        if not self._content_change(file_id):
1992
 
            return self._transform._tree.get_file_mtime(file_id)
1993
 
        return self._stat_limbo_file(file_id).st_mtime
1994
 
 
1995
 
    def _file_size(self, entry, stat_value):
1996
 
        return self.get_file_size(entry.file_id)
1997
 
 
1998
 
    def get_file_size(self, file_id):
 
2277
            return self._transform._tree.get_file_mtime(
 
2278
                self._transform._tree.id2path(file_id))
 
2279
        trans_id = self._path2trans_id(path)
 
2280
        return self._stat_limbo_file(trans_id).st_mtime
 
2281
 
 
2282
    def get_file_size(self, path):
1999
2283
        """See Tree.get_file_size"""
2000
 
        if self.kind(file_id) == 'file':
2001
 
            return self._transform._tree.get_file_size(file_id)
 
2284
        trans_id = self._path2trans_id(path)
 
2285
        if trans_id is None:
 
2286
            raise errors.NoSuchFile(path)
 
2287
        kind = self._transform.final_kind(trans_id)
 
2288
        if kind != 'file':
 
2289
            return None
 
2290
        if trans_id in self._transform._new_contents:
 
2291
            return self._stat_limbo_file(trans_id).st_size
 
2292
        if self.kind(path) == 'file':
 
2293
            return self._transform._tree.get_file_size(path)
2002
2294
        else:
2003
2295
            return None
2004
2296
 
2005
 
    def get_file_sha1(self, file_id, path=None, stat_value=None):
2006
 
        trans_id = self._transform.trans_id_file_id(file_id)
2007
 
        kind = self._transform._new_contents.get(trans_id)
2008
 
        if kind is None:
2009
 
            return self._transform._tree.get_file_sha1(file_id)
2010
 
        if kind == 'file':
2011
 
            fileobj = self.get_file(file_id)
2012
 
            try:
 
2297
    def get_file_verifier(self, path, stat_value=None):
 
2298
        trans_id = self._path2trans_id(path)
 
2299
        if trans_id is None:
 
2300
            raise errors.NoSuchFile(path)
 
2301
        kind = self._transform._new_contents.get(trans_id)
 
2302
        if kind is None:
 
2303
            return self._transform._tree.get_file_verifier(path)
 
2304
        if kind == 'file':
 
2305
            with self.get_file(path) as fileobj:
 
2306
                return ("SHA1", sha_file(fileobj))
 
2307
 
 
2308
    def get_file_sha1(self, path, stat_value=None):
 
2309
        trans_id = self._path2trans_id(path)
 
2310
        if trans_id is None:
 
2311
            raise errors.NoSuchFile(path)
 
2312
        kind = self._transform._new_contents.get(trans_id)
 
2313
        if kind is None:
 
2314
            return self._transform._tree.get_file_sha1(path)
 
2315
        if kind == 'file':
 
2316
            with self.get_file(path) as fileobj:
2013
2317
                return sha_file(fileobj)
2014
 
            finally:
2015
 
                fileobj.close()
2016
2318
 
2017
 
    def is_executable(self, file_id, path=None):
2018
 
        if file_id is None:
 
2319
    def is_executable(self, path):
 
2320
        trans_id = self._path2trans_id(path)
 
2321
        if trans_id is None:
2019
2322
            return False
2020
 
        trans_id = self._transform.trans_id_file_id(file_id)
2021
2323
        try:
2022
2324
            return self._transform._new_executability[trans_id]
2023
2325
        except KeyError:
2024
2326
            try:
2025
 
                return self._transform._tree.is_executable(file_id, path)
2026
 
            except OSError, e:
 
2327
                return self._transform._tree.is_executable(path)
 
2328
            except OSError as e:
2027
2329
                if e.errno == errno.ENOENT:
2028
2330
                    return False
2029
2331
                raise
2030
 
            except errors.NoSuchId:
 
2332
            except errors.NoSuchFile:
2031
2333
                return False
2032
2334
 
 
2335
    def has_filename(self, path):
 
2336
        trans_id = self._path2trans_id(path)
 
2337
        if trans_id in self._transform._new_contents:
 
2338
            return True
 
2339
        elif trans_id in self._transform._removed_contents:
 
2340
            return False
 
2341
        else:
 
2342
            return self._transform._tree.has_filename(path)
 
2343
 
2033
2344
    def path_content_summary(self, path):
2034
2345
        trans_id = self._path2trans_id(path)
2035
2346
        tt = self._transform
2048
2359
            if kind == 'file':
2049
2360
                statval = os.lstat(limbo_name)
2050
2361
                size = statval.st_size
2051
 
                if not supports_executable():
 
2362
                if not tt._limbo_supports_executable():
2052
2363
                    executable = False
2053
2364
                else:
2054
2365
                    executable = statval.st_mode & S_IEXEC
2056
2367
                size = None
2057
2368
                executable = None
2058
2369
            if kind == 'symlink':
2059
 
                link_or_sha1 = os.readlink(limbo_name).decode(osutils._fs_enc)
 
2370
                link_or_sha1 = os.readlink(limbo_name)
 
2371
                if not isinstance(link_or_sha1, text_type):
 
2372
                    link_or_sha1 = link_or_sha1.decode(osutils._fs_enc)
2060
2373
        executable = tt._new_executability.get(trans_id, executable)
2061
2374
        return kind, size, executable, link_or_sha1
2062
2375
 
2063
2376
    def iter_changes(self, from_tree, include_unchanged=False,
2064
 
                      specific_files=None, pb=None, extra_trees=None,
2065
 
                      require_versioned=True, want_unversioned=False):
 
2377
                     specific_files=None, pb=None, extra_trees=None,
 
2378
                     require_versioned=True, want_unversioned=False):
2066
2379
        """See InterTree.iter_changes.
2067
2380
 
2068
2381
        This has a fast path that is only used when the from_tree matches
2069
2382
        the transform tree, and no fancy options are supplied.
2070
2383
        """
2071
 
        if (from_tree is not self._transform._tree or include_unchanged or
2072
 
            specific_files or want_unversioned):
 
2384
        if (from_tree is not self._transform._tree or include_unchanged
 
2385
                or specific_files or want_unversioned):
2073
2386
            return tree.InterTree(from_tree, self).iter_changes(
2074
2387
                include_unchanged=include_unchanged,
2075
2388
                specific_files=specific_files,
2081
2394
            raise ValueError('want_unversioned is not supported')
2082
2395
        return self._transform.iter_changes()
2083
2396
 
2084
 
    def get_file(self, file_id, path=None):
 
2397
    def get_file(self, path):
2085
2398
        """See Tree.get_file"""
 
2399
        file_id = self.path2id(path)
2086
2400
        if not self._content_change(file_id):
2087
 
            return self._transform._tree.get_file(file_id, path)
2088
 
        trans_id = self._transform.trans_id_file_id(file_id)
 
2401
            return self._transform._tree.get_file(path)
 
2402
        trans_id = self._path2trans_id(path)
2089
2403
        name = self._transform._limbo_name(trans_id)
2090
2404
        return open(name, 'rb')
2091
2405
 
2092
 
    def get_file_with_stat(self, file_id, path=None):
2093
 
        return self.get_file(file_id, path), None
 
2406
    def get_file_with_stat(self, path):
 
2407
        return self.get_file(path), None
2094
2408
 
2095
 
    def annotate_iter(self, file_id,
 
2409
    def annotate_iter(self, path,
2096
2410
                      default_revision=_mod_revision.CURRENT_REVISION):
 
2411
        file_id = self.path2id(path)
2097
2412
        changes = self._iter_changes_cache.get(file_id)
2098
2413
        if changes is None:
2099
2414
            get_old = True
2104
2419
                return None
2105
2420
            get_old = (kind[0] == 'file' and versioned[0])
2106
2421
        if get_old:
2107
 
            old_annotation = self._transform._tree.annotate_iter(file_id,
2108
 
                default_revision=default_revision)
 
2422
            old_annotation = self._transform._tree.annotate_iter(
 
2423
                path, default_revision=default_revision)
2109
2424
        else:
2110
2425
            old_annotation = []
2111
2426
        if changes is None:
2120
2435
        #       It would be nice to be able to use the new Annotator based
2121
2436
        #       approach, as well.
2122
2437
        return annotate.reannotate([old_annotation],
2123
 
                                   self.get_file(file_id).readlines(),
 
2438
                                   self.get_file(path).readlines(),
2124
2439
                                   default_revision)
2125
2440
 
2126
 
    def get_symlink_target(self, file_id):
 
2441
    def get_symlink_target(self, path):
2127
2442
        """See Tree.get_symlink_target"""
 
2443
        file_id = self.path2id(path)
2128
2444
        if not self._content_change(file_id):
2129
 
            return self._transform._tree.get_symlink_target(file_id)
2130
 
        trans_id = self._transform.trans_id_file_id(file_id)
 
2445
            return self._transform._tree.get_symlink_target(path)
 
2446
        trans_id = self._path2trans_id(path)
2131
2447
        name = self._transform._limbo_name(trans_id)
2132
2448
        return osutils.readlink(name)
2133
2449
 
2144
2460
                path_from_root = self._final_paths.get_path(child_id)
2145
2461
                basename = self._transform.final_name(child_id)
2146
2462
                file_id = self._transform.final_file_id(child_id)
2147
 
                try:
2148
 
                    kind = self._transform.final_kind(child_id)
 
2463
                kind = self._transform.final_kind(child_id)
 
2464
                if kind is not None:
2149
2465
                    versioned_kind = kind
2150
 
                except NoSuchFile:
 
2466
                else:
2151
2467
                    kind = 'unknown'
2152
 
                    versioned_kind = self._transform._tree.stored_kind(file_id)
 
2468
                    versioned_kind = self._transform._tree.stored_kind(
 
2469
                        self._transform._tree.id2path(file_id))
2153
2470
                if versioned_kind == 'directory':
2154
2471
                    subdirs.append(child_id)
2155
2472
                children.append((path_from_root, basename, kind, None,
2184
2501
    The underlying tree must not be manipulated between calls, or else
2185
2502
    the results will likely be incorrect.
2186
2503
    """
 
2504
 
2187
2505
    def __init__(self, transform):
2188
2506
        object.__init__(self)
2189
2507
        self._known_paths = {}
2191
2509
 
2192
2510
    def _determine_path(self, trans_id):
2193
2511
        if (trans_id == self.transform.root or trans_id == ROOT_PARENT):
2194
 
            return ""
 
2512
            return u""
2195
2513
        name = self.transform.final_name(trans_id)
2196
2514
        parent_id = self.transform.final_parent(trans_id)
2197
2515
        if parent_id == self.transform.root:
2209
2527
        return [(self.get_path(t), t) for t in trans_ids]
2210
2528
 
2211
2529
 
2212
 
 
2213
2530
def topology_sorted_ids(tree):
2214
2531
    """Determine the topological order of the ids in a tree"""
2215
2532
    file_ids = list(tree)
2243
2560
    :param delta_from_tree: If true, build_tree may use the input Tree to
2244
2561
        generate the inventory delta.
2245
2562
    """
2246
 
    wt.lock_tree_write()
2247
 
    try:
2248
 
        tree.lock_read()
 
2563
    with wt.lock_tree_write(), tree.lock_read():
 
2564
        if accelerator_tree is not None:
 
2565
            accelerator_tree.lock_read()
2249
2566
        try:
 
2567
            return _build_tree(tree, wt, accelerator_tree, hardlink,
 
2568
                               delta_from_tree)
 
2569
        finally:
2250
2570
            if accelerator_tree is not None:
2251
 
                accelerator_tree.lock_read()
2252
 
            try:
2253
 
                return _build_tree(tree, wt, accelerator_tree, hardlink,
2254
 
                                   delta_from_tree)
2255
 
            finally:
2256
 
                if accelerator_tree is not None:
2257
 
                    accelerator_tree.unlock()
2258
 
        finally:
2259
 
            tree.unlock()
2260
 
    finally:
2261
 
        wt.unlock()
 
2571
                accelerator_tree.unlock()
2262
2572
 
2263
2573
 
2264
2574
def _build_tree(tree, wt, accelerator_tree, hardlink, delta_from_tree):
2265
2575
    """See build_tree."""
2266
 
    for num, _unused in enumerate(wt.all_file_ids()):
 
2576
    for num, _unused in enumerate(wt.all_versioned_paths()):
2267
2577
        if num > 0:  # more than just a root
2268
2578
            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
2579
    file_trans_id = {}
2273
 
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2580
    top_pb = ui.ui_factory.nested_progress_bar()
2274
2581
    pp = ProgressPhase("Build phase", 2, top_pb)
2275
 
    if tree.inventory.root is not None:
 
2582
    if tree.get_root_id() is not None:
2276
2583
        # This is kind of a hack: we should be altering the root
2277
2584
        # as part of the regular tree shape diff logic.
2278
2585
        # The conditional test here is to avoid doing an
2287
2594
    divert = set()
2288
2595
    try:
2289
2596
        pp.next_phase()
2290
 
        file_trans_id[wt.get_root_id()] = \
2291
 
            tt.trans_id_tree_file_id(wt.get_root_id())
2292
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
2293
 
        try:
 
2597
        file_trans_id[wt.get_root_id()] = tt.trans_id_tree_path('')
 
2598
        with ui.ui_factory.nested_progress_bar() as pb:
2294
2599
            deferred_contents = []
2295
2600
            num = 0
2296
 
            total = len(tree.inventory)
 
2601
            total = len(tree.all_versioned_paths())
2297
2602
            if delta_from_tree:
2298
2603
                precomputed_delta = []
2299
2604
            else:
2300
2605
                precomputed_delta = None
 
2606
            # Check if tree inventory has content. If so, we populate
 
2607
            # existing_files with the directory content. If there are no
 
2608
            # entries we skip populating existing_files as its not used.
 
2609
            # This improves performance and unncessary work on large
 
2610
            # directory trees. (#501307)
 
2611
            if total > 0:
 
2612
                existing_files = set()
 
2613
                for dir, files in wt.walkdirs():
 
2614
                    existing_files.update(f[0] for f in files)
2301
2615
            for num, (tree_path, entry) in \
2302
 
                enumerate(tree.inventory.iter_entries_by_dir()):
2303
 
                pb.update("Building tree", num - len(deferred_contents), total)
 
2616
                    enumerate(tree.iter_entries_by_dir()):
 
2617
                pb.update(gettext("Building tree"), num
 
2618
                          - len(deferred_contents), total)
2304
2619
                if entry.parent_id is None:
2305
2620
                    continue
2306
2621
                reparent = False
2312
2627
                    kind = file_kind(target_path)
2313
2628
                    if kind == "directory":
2314
2629
                        try:
2315
 
                            bzrdir.BzrDir.open(target_path)
 
2630
                            controldir.ControlDir.open(target_path)
2316
2631
                        except errors.NotBranchError:
2317
2632
                            pass
2318
2633
                        else:
2319
2634
                            divert.add(file_id)
2320
 
                    if (file_id not in divert and
2321
 
                        _content_match(tree, entry, file_id, kind,
2322
 
                        target_path)):
 
2635
                    if (file_id not in divert
 
2636
                        and _content_match(
 
2637
                            tree, entry, tree_path, file_id, kind,
 
2638
                            target_path)):
2323
2639
                        tt.delete_contents(tt.trans_id_tree_path(tree_path))
2324
2640
                        if kind == 'directory':
2325
2641
                            reparent = True
2330
2646
                    trans_id = tt.create_path(entry.name, parent_id)
2331
2647
                    file_trans_id[file_id] = trans_id
2332
2648
                    tt.version_file(file_id, trans_id)
2333
 
                    executable = tree.is_executable(file_id, tree_path)
 
2649
                    executable = tree.is_executable(tree_path)
2334
2650
                    if executable:
2335
2651
                        tt.set_executability(executable, trans_id)
2336
 
                    trans_data = (trans_id, tree_path)
2337
 
                    deferred_contents.append((file_id, trans_data))
 
2652
                    trans_data = (trans_id, file_id,
 
2653
                                  tree_path, entry.text_sha1)
 
2654
                    deferred_contents.append((tree_path, trans_data))
2338
2655
                else:
2339
 
                    file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
2340
 
                                                          tree)
 
2656
                    file_trans_id[file_id] = new_by_entry(
 
2657
                        tree_path, tt, entry, parent_id, tree)
2341
2658
                if reparent:
2342
2659
                    new_trans_id = file_trans_id[file_id]
2343
2660
                    old_parent = tt.trans_id_tree_path(tree_path)
2345
2662
            offset = num + 1 - len(deferred_contents)
2346
2663
            _create_files(tt, tree, deferred_contents, pb, offset,
2347
2664
                          accelerator_tree, hardlink)
2348
 
        finally:
2349
 
            pb.finished()
2350
2665
        pp.next_phase()
2351
2666
        divert_trans = set(file_trans_id[f] for f in divert)
2352
 
        resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
 
2667
 
 
2668
        def resolver(t, c):
 
2669
            return resolve_checkout(t, c, divert_trans)
2353
2670
        raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
2354
2671
        if len(raw_conflicts) > 0:
2355
2672
            precomputed_delta = None
2356
2673
        conflicts = cook_conflicts(raw_conflicts, tt)
2357
2674
        for conflict in conflicts:
2358
 
            warning(conflict)
 
2675
            trace.warning(text_type(conflict))
2359
2676
        try:
2360
2677
            wt.add_conflicts(conflicts)
2361
2678
        except errors.UnsupportedOperation:
2376
2693
        new_desired_files = desired_files
2377
2694
    else:
2378
2695
        iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
2379
 
        unchanged = [(f, p[1]) for (f, p, c, v, d, n, k, e)
 
2696
        unchanged = [(p[0], p[1]) for (f, p, c, v, d, n, k, e)
2380
2697
                     in iter if not (c or e[0] != e[1])]
2381
2698
        if accelerator_tree.supports_content_filtering():
2382
 
            unchanged = [(f, p) for (f, p) in unchanged
2383
 
                         if not accelerator_tree.iter_search_rules([p]).next()]
 
2699
            unchanged = [(tp, ap) for (tp, ap) in unchanged
 
2700
                         if not next(accelerator_tree.iter_search_rules([ap]))]
2384
2701
        unchanged = dict(unchanged)
2385
2702
        new_desired_files = []
2386
2703
        count = 0
2387
 
        for file_id, (trans_id, tree_path) in desired_files:
2388
 
            accelerator_path = unchanged.get(file_id)
 
2704
        for unused_tree_path, (trans_id, file_id, tree_path, text_sha1) in desired_files:
 
2705
            accelerator_path = unchanged.get(tree_path)
2389
2706
            if accelerator_path is None:
2390
 
                new_desired_files.append((file_id, (trans_id, tree_path)))
 
2707
                new_desired_files.append((tree_path,
 
2708
                                          (trans_id, file_id, tree_path, text_sha1)))
2391
2709
                continue
2392
 
            pb.update('Adding file contents', count + offset, total)
 
2710
            pb.update(gettext('Adding file contents'), count + offset, total)
2393
2711
            if hardlink:
2394
2712
                tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
2395
2713
                                   trans_id)
2396
2714
            else:
2397
 
                contents = accelerator_tree.get_file(file_id, accelerator_path)
2398
 
                if wt.supports_content_filtering():
2399
 
                    filters = wt._content_filter_stack(tree_path)
2400
 
                    contents = filtered_output_bytes(contents, filters,
2401
 
                        ContentFilterContext(tree_path, tree))
2402
 
                try:
2403
 
                    tt.create_file(contents, trans_id)
2404
 
                finally:
2405
 
                    try:
2406
 
                        contents.close()
2407
 
                    except AttributeError:
2408
 
                        # after filtering, contents may no longer be file-like
2409
 
                        pass
 
2715
                with accelerator_tree.get_file(accelerator_path) as f:
 
2716
                    chunks = osutils.file_iterator(f)
 
2717
                    if wt.supports_content_filtering():
 
2718
                        filters = wt._content_filter_stack(tree_path)
 
2719
                        chunks = filtered_output_bytes(chunks, filters,
 
2720
                                                       ContentFilterContext(tree_path, tree))
 
2721
                    tt.create_file(chunks, trans_id, sha1=text_sha1)
2410
2722
            count += 1
2411
2723
        offset += count
2412
 
    for count, ((trans_id, tree_path), contents) in enumerate(
 
2724
    for count, ((trans_id, file_id, tree_path, text_sha1), contents) in enumerate(
2413
2725
            tree.iter_files_bytes(new_desired_files)):
2414
2726
        if wt.supports_content_filtering():
2415
2727
            filters = wt._content_filter_stack(tree_path)
2416
2728
            contents = filtered_output_bytes(contents, filters,
2417
 
                ContentFilterContext(tree_path, tree))
2418
 
        tt.create_file(contents, trans_id)
2419
 
        pb.update('Adding file contents', count + offset, total)
 
2729
                                             ContentFilterContext(tree_path, tree))
 
2730
        tt.create_file(contents, trans_id, sha1=text_sha1)
 
2731
        pb.update(gettext('Adding file contents'), count + offset, total)
2420
2732
 
2421
2733
 
2422
2734
def _reparent_children(tt, old_parent, new_parent):
2423
2735
    for child in tt.iter_tree_children(old_parent):
2424
2736
        tt.adjust_path(tt.final_name(child), new_parent, child)
2425
2737
 
 
2738
 
2426
2739
def _reparent_transform_children(tt, old_parent, new_parent):
2427
2740
    by_parent = tt.by_parent()
2428
2741
    for child in by_parent[old_parent]:
2429
2742
        tt.adjust_path(tt.final_name(child), new_parent, child)
2430
2743
    return by_parent[old_parent]
2431
2744
 
2432
 
def _content_match(tree, entry, file_id, kind, target_path):
 
2745
 
 
2746
def _content_match(tree, entry, tree_path, file_id, kind, target_path):
2433
2747
    if entry.kind != kind:
2434
2748
        return False
2435
2749
    if entry.kind == "directory":
2436
2750
        return True
2437
2751
    if entry.kind == "file":
2438
 
        if tree.get_file(file_id).read() == file(target_path, 'rb').read():
2439
 
            return True
 
2752
        with open(target_path, 'rb') as f1, \
 
2753
                tree.get_file(tree_path) as f2:
 
2754
            if osutils.compare_files(f1, f2):
 
2755
                return True
2440
2756
    elif entry.kind == "symlink":
2441
 
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
 
2757
        if tree.get_symlink_target(tree_path) == os.readlink(target_path):
2442
2758
            return True
2443
2759
    return False
2444
2760
 
2461
2777
        # resolved
2462
2778
        final_parent = tt.final_parent(old_file)
2463
2779
        if new_file in divert:
2464
 
            new_name = tt.final_name(old_file)+'.diverted'
 
2780
            new_name = tt.final_name(old_file) + '.diverted'
2465
2781
            tt.adjust_path(new_name, final_parent, new_file)
2466
2782
            new_conflicts.add((c_type, 'Diverted to',
2467
2783
                               new_file, old_file))
2468
2784
        else:
2469
 
            new_name = tt.final_name(old_file)+'.moved'
 
2785
            new_name = tt.final_name(old_file) + '.moved'
2470
2786
            tt.adjust_path(new_name, final_parent, old_file)
2471
2787
            new_conflicts.add((c_type, 'Moved existing file to',
2472
2788
                               old_file, new_file))
2473
2789
    return new_conflicts
2474
2790
 
2475
2791
 
2476
 
def new_by_entry(tt, entry, parent_id, tree):
 
2792
def new_by_entry(path, tt, entry, parent_id, tree):
2477
2793
    """Create a new file according to its inventory entry"""
2478
2794
    name = entry.name
2479
2795
    kind = entry.kind
2480
2796
    if kind == 'file':
2481
 
        contents = tree.get_file(entry.file_id).readlines()
2482
 
        executable = tree.is_executable(entry.file_id)
2483
 
        return tt.new_file(name, parent_id, contents, entry.file_id,
2484
 
                           executable)
 
2797
        with tree.get_file(path) as f:
 
2798
            executable = tree.is_executable(path)
 
2799
            return tt.new_file(
 
2800
                name, parent_id, osutils.file_iterator(f), entry.file_id,
 
2801
                executable)
2485
2802
    elif kind in ('directory', 'tree-reference'):
2486
2803
        trans_id = tt.new_directory(name, parent_id, entry.file_id)
2487
2804
        if kind == 'tree-reference':
2488
2805
            tt.set_tree_reference(entry.reference_revision, trans_id)
2489
2806
        return trans_id
2490
2807
    elif kind == 'symlink':
2491
 
        target = tree.get_symlink_target(entry.file_id)
 
2808
        target = tree.get_symlink_target(path)
2492
2809
        return tt.new_symlink(name, parent_id, target, entry.file_id)
2493
2810
    else:
2494
2811
        raise errors.BadFileKindError(name, kind)
2495
2812
 
2496
2813
 
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
 
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2514
 
    filter_tree_path=None):
 
2814
def create_from_tree(tt, trans_id, tree, path, file_id=None, chunks=None,
 
2815
                     filter_tree_path=None):
2515
2816
    """Create new file contents according to tree contents.
2516
 
    
 
2817
 
2517
2818
    :param filter_tree_path: the tree path to use to lookup
2518
2819
      content filters to apply to the bytes output in the working tree.
2519
2820
      This only applies if the working tree supports content filtering.
2520
2821
    """
2521
 
    kind = tree.kind(file_id)
 
2822
    kind = tree.kind(path)
2522
2823
    if kind == 'directory':
2523
2824
        tt.create_directory(trans_id)
2524
2825
    elif kind == "file":
2525
 
        if bytes is None:
2526
 
            tree_file = tree.get_file(file_id)
2527
 
            try:
2528
 
                bytes = tree_file.readlines()
2529
 
            finally:
2530
 
                tree_file.close()
2531
 
        wt = tt._tree
2532
 
        if wt.supports_content_filtering() and filter_tree_path is not None:
2533
 
            filters = wt._content_filter_stack(filter_tree_path)
2534
 
            bytes = filtered_output_bytes(bytes, filters,
2535
 
                ContentFilterContext(filter_tree_path, tree))
2536
 
        tt.create_file(bytes, trans_id)
 
2826
        if chunks is None:
 
2827
            f = tree.get_file(path)
 
2828
            chunks = osutils.file_iterator(f)
 
2829
        else:
 
2830
            f = None
 
2831
        try:
 
2832
            wt = tt._tree
 
2833
            if wt.supports_content_filtering() and filter_tree_path is not None:
 
2834
                filters = wt._content_filter_stack(filter_tree_path)
 
2835
                chunks = filtered_output_bytes(
 
2836
                    chunks, filters,
 
2837
                    ContentFilterContext(filter_tree_path, tree))
 
2838
            tt.create_file(chunks, trans_id)
 
2839
        finally:
 
2840
            if f is not None:
 
2841
                f.close()
2537
2842
    elif kind == "symlink":
2538
 
        tt.create_symlink(tree.get_symlink_target(file_id), trans_id)
 
2843
        tt.create_symlink(tree.get_symlink_target(path), trans_id)
2539
2844
    else:
2540
2845
        raise AssertionError('Unknown kind %r' % kind)
2541
2846
 
2546
2851
        tt.set_executability(entry.executable, trans_id)
2547
2852
 
2548
2853
 
2549
 
def get_backup_name(entry, by_parent, parent_trans_id, tt):
2550
 
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
2551
 
 
2552
 
 
2553
 
def _get_backup_name(name, by_parent, parent_trans_id, tt):
2554
 
    """Produce a backup-style name that appears to be available"""
2555
 
    def name_gen():
2556
 
        counter = 1
2557
 
        while True:
2558
 
            yield "%s.~%d~" % (name, counter)
2559
 
            counter += 1
2560
 
    for new_name in name_gen():
2561
 
        if not tt.has_named_child(by_parent, parent_trans_id, new_name):
2562
 
            return new_name
2563
 
 
2564
 
 
2565
 
def _entry_changes(file_id, entry, working_tree):
2566
 
    """Determine in which ways the inventory entry has changed.
2567
 
 
2568
 
    Returns booleans: has_contents, content_mod, meta_mod
2569
 
    has_contents means there are currently contents, but they differ
2570
 
    contents_mod means contents need to be modified
2571
 
    meta_mod means the metadata needs to be modified
2572
 
    """
2573
 
    cur_entry = working_tree.inventory[file_id]
2574
 
    try:
2575
 
        working_kind = working_tree.kind(file_id)
2576
 
        has_contents = True
2577
 
    except NoSuchFile:
2578
 
        has_contents = False
2579
 
        contents_mod = True
2580
 
        meta_mod = False
2581
 
    if has_contents is True:
2582
 
        if entry.kind != working_kind:
2583
 
            contents_mod, meta_mod = True, False
2584
 
        else:
2585
 
            cur_entry._read_tree_state(working_tree.id2path(file_id),
2586
 
                                       working_tree)
2587
 
            contents_mod, meta_mod = entry.detect_changes(cur_entry)
2588
 
            cur_entry._forget_tree_state()
2589
 
    return has_contents, contents_mod, meta_mod
2590
 
 
2591
 
 
2592
2854
def revert(working_tree, target_tree, filenames, backups=False,
2593
2855
           pb=None, change_reporter=None):
2594
2856
    """Revert a working tree's contents to those of a target tree."""
2595
 
    target_tree.lock_read()
2596
2857
    pb = ui.ui_factory.nested_progress_bar()
2597
 
    tt = TreeTransform(working_tree, pb)
2598
2858
    try:
2599
 
        pp = ProgressPhase("Revert phase", 3, pb)
2600
 
        conflicts, merge_modified = _prepare_revert_transform(
2601
 
            working_tree, target_tree, tt, filenames, backups, pp)
2602
 
        if change_reporter:
2603
 
            change_reporter = delta._ChangeReporter(
2604
 
                unversioned_filter=working_tree.is_ignored)
2605
 
            delta.report_changes(tt.iter_changes(), change_reporter)
2606
 
        for conflict in conflicts:
2607
 
            warning(conflict)
2608
 
        pp.next_phase()
2609
 
        tt.apply()
2610
 
        working_tree.set_merge_modified(merge_modified)
 
2859
        with target_tree.lock_read(), TreeTransform(working_tree, pb) as tt:
 
2860
            pp = ProgressPhase("Revert phase", 3, pb)
 
2861
            conflicts, merge_modified = _prepare_revert_transform(
 
2862
                working_tree, target_tree, tt, filenames, backups, pp)
 
2863
            if change_reporter:
 
2864
                change_reporter = delta._ChangeReporter(
 
2865
                    unversioned_filter=working_tree.is_ignored)
 
2866
                delta.report_changes(tt.iter_changes(), change_reporter)
 
2867
            for conflict in conflicts:
 
2868
                trace.warning(text_type(conflict))
 
2869
            pp.next_phase()
 
2870
            tt.apply()
 
2871
            if working_tree.supports_merge_modified():
 
2872
                working_tree.set_merge_modified(merge_modified)
2611
2873
    finally:
2612
 
        target_tree.unlock()
2613
 
        tt.finalize()
2614
2874
        pb.clear()
2615
2875
    return conflicts
2616
2876
 
2618
2878
def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
2619
2879
                              backups, pp, basis_tree=None,
2620
2880
                              merge_modified=None):
2621
 
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2622
 
    try:
 
2881
    with ui.ui_factory.nested_progress_bar() as child_pb:
2623
2882
        if merge_modified is None:
2624
2883
            merge_modified = working_tree.merge_modified()
2625
2884
        merge_modified = _alter_files(working_tree, target_tree, tt,
2626
2885
                                      child_pb, filenames, backups,
2627
2886
                                      merge_modified, basis_tree)
2628
 
    finally:
2629
 
        child_pb.finished()
2630
 
    child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
2631
 
    try:
2632
 
        raw_conflicts = resolve_conflicts(tt, child_pb,
2633
 
            lambda t, c: conflict_pass(t, c, target_tree))
2634
 
    finally:
2635
 
        child_pb.finished()
 
2887
    with ui.ui_factory.nested_progress_bar() as child_pb:
 
2888
        raw_conflicts = resolve_conflicts(
 
2889
            tt, child_pb, lambda t, c: conflict_pass(t, c, target_tree))
2636
2890
    conflicts = cook_conflicts(raw_conflicts, tt)
2637
2891
    return conflicts, merge_modified
2638
2892
 
2641
2895
                 backups, merge_modified, basis_tree=None):
2642
2896
    if basis_tree is not None:
2643
2897
        basis_tree.lock_read()
2644
 
    change_list = target_tree.iter_changes(working_tree,
2645
 
        specific_files=specific_files, pb=pb)
2646
 
    if target_tree.get_root_id() is None:
 
2898
    # We ask the working_tree for its changes relative to the target, rather
 
2899
    # than the target changes relative to the working tree. Because WT4 has an
 
2900
    # optimizer to compare itself to a target, but no optimizer for the
 
2901
    # reverse.
 
2902
    change_list = working_tree.iter_changes(
 
2903
        target_tree, specific_files=specific_files, pb=pb)
 
2904
    if not target_tree.is_versioned(u''):
2647
2905
        skip_root = True
2648
2906
    else:
2649
2907
        skip_root = False
2650
2908
    try:
2651
2909
        deferred_files = []
2652
2910
        for id_num, (file_id, path, changed_content, versioned, parent, name,
2653
 
                kind, executable) in enumerate(change_list):
2654
 
            if skip_root and file_id[0] is not None and parent[0] is None:
 
2911
                     kind, executable) in enumerate(change_list):
 
2912
            target_path, wt_path = path
 
2913
            target_versioned, wt_versioned = versioned
 
2914
            target_parent, wt_parent = parent
 
2915
            target_name, wt_name = name
 
2916
            target_kind, wt_kind = kind
 
2917
            target_executable, wt_executable = executable
 
2918
            if skip_root and wt_parent is None:
2655
2919
                continue
2656
2920
            trans_id = tt.trans_id_file_id(file_id)
2657
2921
            mode_id = None
2658
2922
            if changed_content:
2659
2923
                keep_content = False
2660
 
                if kind[0] == 'file' and (backups or kind[1] is None):
2661
 
                    wt_sha1 = working_tree.get_file_sha1(file_id)
 
2924
                if wt_kind == 'file' and (backups or target_kind is None):
 
2925
                    wt_sha1 = working_tree.get_file_sha1(wt_path)
2662
2926
                    if merge_modified.get(file_id) != wt_sha1:
2663
2927
                        # acquire the basis tree lazily to prevent the
2664
2928
                        # expense of accessing it when it's not needed ?
2666
2930
                        if basis_tree is None:
2667
2931
                            basis_tree = working_tree.basis_tree()
2668
2932
                            basis_tree.lock_read()
2669
 
                        if file_id in basis_tree:
2670
 
                            if wt_sha1 != basis_tree.get_file_sha1(file_id):
2671
 
                                keep_content = True
2672
 
                        elif kind[1] is None and not versioned[1]:
2673
 
                            keep_content = True
2674
 
                if kind[0] is not None:
 
2933
                        basis_path = find_previous_path(
 
2934
                            working_tree, basis_tree, wt_path)
 
2935
                        if basis_path is None:
 
2936
                            if target_kind is None and not target_versioned:
 
2937
                                keep_content = True
 
2938
                        else:
 
2939
                            if wt_sha1 != basis_tree.get_file_sha1(basis_path):
 
2940
                                keep_content = True
 
2941
                if wt_kind is not None:
2675
2942
                    if not keep_content:
2676
2943
                        tt.delete_contents(trans_id)
2677
 
                    elif kind[1] is not None:
2678
 
                        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)
 
2944
                    elif target_kind is not None:
 
2945
                        parent_trans_id = tt.trans_id_file_id(wt_parent)
 
2946
                        backup_name = tt._available_backup_name(
 
2947
                            wt_name, parent_trans_id)
2682
2948
                        tt.adjust_path(backup_name, parent_trans_id, trans_id)
2683
 
                        new_trans_id = tt.create_path(name[0], parent_trans_id)
2684
 
                        if versioned == (True, True):
 
2949
                        new_trans_id = tt.create_path(wt_name, parent_trans_id)
 
2950
                        if wt_versioned and target_versioned:
2685
2951
                            tt.unversion_file(trans_id)
2686
2952
                            tt.version_file(file_id, new_trans_id)
2687
2953
                        # New contents should have the same unix perms as old
2688
2954
                        # contents
2689
2955
                        mode_id = trans_id
2690
2956
                        trans_id = new_trans_id
2691
 
                if kind[1] in ('directory', 'tree-reference'):
 
2957
                if target_kind in ('directory', 'tree-reference'):
2692
2958
                    tt.create_directory(trans_id)
2693
 
                    if kind[1] == 'tree-reference':
2694
 
                        revision = target_tree.get_reference_revision(file_id,
2695
 
                                                                      path[1])
 
2959
                    if target_kind == 'tree-reference':
 
2960
                        revision = target_tree.get_reference_revision(
 
2961
                            target_path)
2696
2962
                        tt.set_tree_reference(revision, trans_id)
2697
 
                elif kind[1] == 'symlink':
2698
 
                    tt.create_symlink(target_tree.get_symlink_target(file_id),
2699
 
                                      trans_id)
2700
 
                elif kind[1] == 'file':
2701
 
                    deferred_files.append((file_id, (trans_id, mode_id)))
 
2963
                elif target_kind == 'symlink':
 
2964
                    tt.create_symlink(target_tree.get_symlink_target(
 
2965
                        target_path), trans_id)
 
2966
                elif target_kind == 'file':
 
2967
                    deferred_files.append(
 
2968
                        (target_path, (trans_id, mode_id, file_id)))
2702
2969
                    if basis_tree is None:
2703
2970
                        basis_tree = working_tree.basis_tree()
2704
2971
                        basis_tree.lock_read()
2705
 
                    new_sha1 = target_tree.get_file_sha1(file_id)
2706
 
                    if (file_id in basis_tree and new_sha1 ==
2707
 
                        basis_tree.get_file_sha1(file_id)):
 
2972
                    new_sha1 = target_tree.get_file_sha1(target_path)
 
2973
                    basis_path = find_previous_path(target_tree, basis_tree, target_path)
 
2974
                    if (basis_path is not None and
 
2975
                            new_sha1 == basis_tree.get_file_sha1(basis_path)):
2708
2976
                        if file_id in merge_modified:
2709
2977
                            del merge_modified[file_id]
2710
2978
                    else:
2711
2979
                        merge_modified[file_id] = new_sha1
2712
2980
 
2713
2981
                    # preserve the execute bit when backing up
2714
 
                    if keep_content and executable[0] == executable[1]:
2715
 
                        tt.set_executability(executable[1], trans_id)
2716
 
                elif kind[1] is not None:
2717
 
                    raise AssertionError(kind[1])
2718
 
            if versioned == (False, True):
 
2982
                    if keep_content and wt_executable == target_executable:
 
2983
                        tt.set_executability(target_executable, trans_id)
 
2984
                elif target_kind is not None:
 
2985
                    raise AssertionError(target_kind)
 
2986
            if not wt_versioned and target_versioned:
2719
2987
                tt.version_file(file_id, trans_id)
2720
 
            if versioned == (True, False):
 
2988
            if wt_versioned and not target_versioned:
2721
2989
                tt.unversion_file(trans_id)
2722
 
            if (name[1] is not None and
2723
 
                (name[0] != name[1] or parent[0] != parent[1])):
2724
 
                if name[1] == '' and parent[1] is None:
 
2990
            if (target_name is not None
 
2991
                    and (wt_name != target_name or wt_parent != target_parent)):
 
2992
                if target_name == '' and target_parent is None:
2725
2993
                    parent_trans = ROOT_PARENT
2726
2994
                else:
2727
 
                    parent_trans = tt.trans_id_file_id(parent[1])
2728
 
                if parent[0] is None and versioned[0]:
2729
 
                    tt.adjust_root_path(name[1], parent_trans)
 
2995
                    parent_trans = tt.trans_id_file_id(target_parent)
 
2996
                if wt_parent is None and wt_versioned:
 
2997
                    tt.adjust_root_path(target_name, parent_trans)
2730
2998
                else:
2731
 
                    tt.adjust_path(name[1], parent_trans, trans_id)
2732
 
            if executable[0] != executable[1] and kind[1] == "file":
2733
 
                tt.set_executability(executable[1], trans_id)
 
2999
                    tt.adjust_path(target_name, parent_trans, trans_id)
 
3000
            if wt_executable != target_executable and target_kind == "file":
 
3001
                tt.set_executability(target_executable, trans_id)
2734
3002
        if working_tree.supports_content_filtering():
2735
 
            for index, ((trans_id, mode_id), bytes) in enumerate(
2736
 
                target_tree.iter_files_bytes(deferred_files)):
2737
 
                file_id = deferred_files[index][0]
 
3003
            for (trans_id, mode_id, file_id), bytes in (
 
3004
                    target_tree.iter_files_bytes(deferred_files)):
2738
3005
                # We're reverting a tree to the target tree so using the
2739
3006
                # target tree to find the file path seems the best choice
2740
3007
                # here IMO - Ian C 27/Oct/2009
2741
3008
                filter_tree_path = target_tree.id2path(file_id)
2742
3009
                filters = working_tree._content_filter_stack(filter_tree_path)
2743
 
                bytes = filtered_output_bytes(bytes, filters,
 
3010
                bytes = filtered_output_bytes(
 
3011
                    bytes, filters,
2744
3012
                    ContentFilterContext(filter_tree_path, working_tree))
2745
3013
                tt.create_file(bytes, trans_id, mode_id)
2746
3014
        else:
2747
 
            for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
2748
 
                deferred_files):
 
3015
            for (trans_id, mode_id, file_id), bytes in target_tree.iter_files_bytes(
 
3016
                    deferred_files):
2749
3017
                tt.create_file(bytes, trans_id, mode_id)
2750
3018
        tt.fixup_new_roots()
2751
3019
    finally:
2759
3027
    if pass_func is None:
2760
3028
        pass_func = conflict_pass
2761
3029
    new_conflicts = set()
2762
 
    pb = ui.ui_factory.nested_progress_bar()
2763
 
    try:
 
3030
    with ui.ui_factory.nested_progress_bar() as pb:
2764
3031
        for n in range(10):
2765
 
            pb.update('Resolution pass', n+1, 10)
 
3032
            pb.update(gettext('Resolution pass'), n + 1, 10)
2766
3033
            conflicts = tt.find_conflicts()
2767
3034
            if len(conflicts) == 0:
2768
3035
                return new_conflicts
2769
3036
            new_conflicts.update(pass_func(tt, conflicts))
2770
3037
        raise MalformedTransform(conflicts=conflicts)
2771
 
    finally:
2772
 
        pb.finished()
2773
3038
 
2774
3039
 
2775
3040
def conflict_pass(tt, conflicts, path_tree=None):
2792
3057
                existing_file, new_file = conflict[2], conflict[1]
2793
3058
            else:
2794
3059
                existing_file, new_file = conflict[1], conflict[2]
2795
 
            new_name = tt.final_name(existing_file)+'.moved'
 
3060
            new_name = tt.final_name(existing_file) + '.moved'
2796
3061
            tt.adjust_path(new_name, final_parent, existing_file)
2797
3062
            new_conflicts.add((c_type, 'Moved existing file to',
2798
3063
                               existing_file, new_file))
2807
3072
 
2808
3073
        elif c_type == 'missing parent':
2809
3074
            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:
 
3075
            if trans_id in tt._removed_contents:
 
3076
                cancel_deletion = True
 
3077
                orphans = tt._get_potential_orphans(trans_id)
 
3078
                if orphans:
 
3079
                    cancel_deletion = False
 
3080
                    # All children are orphans
 
3081
                    for o in orphans:
 
3082
                        try:
 
3083
                            tt.new_orphan(o, trans_id)
 
3084
                        except OrphaningError:
 
3085
                            # Something bad happened so we cancel the directory
 
3086
                            # deletion which will leave it in place with a
 
3087
                            # conflict. The user can deal with it from there.
 
3088
                            # Note that this also catch the case where we don't
 
3089
                            # want to create orphans and leave the directory in
 
3090
                            # place.
 
3091
                            cancel_deletion = True
 
3092
                            break
 
3093
                if cancel_deletion:
 
3094
                    # Cancel the directory deletion
 
3095
                    tt.cancel_deletion(trans_id)
 
3096
                    new_conflicts.add(('deleting parent', 'Not deleting',
 
3097
                                       trans_id))
 
3098
            else:
2815
3099
                create = True
2816
3100
                try:
2817
3101
                    tt.final_name(trans_id)
2820
3104
                        file_id = tt.final_file_id(trans_id)
2821
3105
                        if file_id is None:
2822
3106
                            file_id = tt.inactive_file_id(trans_id)
2823
 
                        entry = path_tree.inventory[file_id]
 
3107
                        _, entry = next(path_tree.iter_entries_by_dir(
 
3108
                            specific_files=[path_tree.id2path(file_id)]))
2824
3109
                        # special-case the other tree root (move its
2825
3110
                        # children to current root)
2826
3111
                        if entry.parent_id is None:
2841
3126
        elif c_type == 'unversioned parent':
2842
3127
            file_id = tt.inactive_file_id(conflict[1])
2843
3128
            # special-case the other tree root (move its children instead)
2844
 
            if path_tree and file_id in path_tree:
2845
 
                if path_tree.inventory[file_id].parent_id is None:
2846
 
                    continue
 
3129
            if path_tree and path_tree.path2id('') == file_id:
 
3130
                # This is the root entry, skip it
 
3131
                continue
2847
3132
            tt.version_file(file_id, conflict[1])
2848
3133
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
2849
3134
        elif c_type == 'non-directory parent':
2852
3137
            parent_name = tt.final_name(parent_id)
2853
3138
            parent_file_id = tt.final_file_id(parent_id)
2854
3139
            new_parent_id = tt.new_directory(parent_name + '.new',
2855
 
                parent_parent, parent_file_id)
 
3140
                                             parent_parent, parent_file_id)
2856
3141
            _reparent_transform_children(tt, parent_id, new_parent_id)
2857
3142
            if parent_file_id is not None:
2858
3143
                tt.unversion_file(parent_id)
2864
3149
 
2865
3150
def cook_conflicts(raw_conflicts, tt):
2866
3151
    """Generate a list of cooked conflicts, sorted by file path"""
2867
 
    from bzrlib.conflicts import Conflict
2868
3152
    conflict_iter = iter_cook_conflicts(raw_conflicts, tt)
2869
 
    return sorted(conflict_iter, key=Conflict.sort_key)
 
3153
    return sorted(conflict_iter, key=conflicts.Conflict.sort_key)
2870
3154
 
2871
3155
 
2872
3156
def iter_cook_conflicts(raw_conflicts, tt):
2873
 
    from bzrlib.conflicts import Conflict
2874
3157
    fp = FinalPaths(tt)
2875
3158
    for conflict in raw_conflicts:
2876
3159
        c_type = conflict[0]
2878
3161
        modified_path = fp.get_path(conflict[2])
2879
3162
        modified_id = tt.final_file_id(conflict[2])
2880
3163
        if len(conflict) == 3:
2881
 
            yield Conflict.factory(c_type, action=action, path=modified_path,
2882
 
                                     file_id=modified_id)
 
3164
            yield conflicts.Conflict.factory(
 
3165
                c_type, action=action, path=modified_path, file_id=modified_id)
2883
3166
 
2884
3167
        else:
2885
3168
            conflicting_path = fp.get_path(conflict[3])
2886
3169
            conflicting_id = tt.final_file_id(conflict[3])
2887
 
            yield Conflict.factory(c_type, action=action, path=modified_path,
2888
 
                                   file_id=modified_id,
2889
 
                                   conflict_path=conflicting_path,
2890
 
                                   conflict_file_id=conflicting_id)
 
3170
            yield conflicts.Conflict.factory(
 
3171
                c_type, action=action, path=modified_path,
 
3172
                file_id=modified_id,
 
3173
                conflict_path=conflicting_path,
 
3174
                conflict_file_id=conflicting_id)
2891
3175
 
2892
3176
 
2893
3177
class _FileMover(object):
2900
3184
    def rename(self, from_, to):
2901
3185
        """Rename a file from one path to another."""
2902
3186
        try:
2903
 
            osutils.rename(from_, to)
2904
 
        except OSError, e:
 
3187
            os.rename(from_, to)
 
3188
        except OSError as e:
2905
3189
            if e.errno in (errno.EEXIST, errno.ENOTEMPTY):
2906
3190
                raise errors.FileExists(to, str(e))
2907
 
            raise
 
3191
            # normal OSError doesn't include filenames so it's hard to see where
 
3192
            # the problem is, see https://bugs.launchpad.net/bzr/+bug/491763
 
3193
            raise errors.TransformRenameFailed(from_, to, str(e), e.errno)
2908
3194
        self.past_renames.append((from_, to))
2909
3195
 
2910
3196
    def pre_delete(self, from_, to):
2920
3206
    def rollback(self):
2921
3207
        """Reverse all renames that have been performed"""
2922
3208
        for from_, to in reversed(self.past_renames):
2923
 
            osutils.rename(to, from_)
 
3209
            try:
 
3210
                os.rename(to, from_)
 
3211
            except OSError as e:
 
3212
                raise errors.TransformRenameFailed(to, from_, str(e), e.errno)
2924
3213
        # after rollback, don't reuse _FileMover
2925
 
        past_renames = None
2926
 
        pending_deletions = None
 
3214
        self.past_renames = None
 
3215
        self.pending_deletions = None
2927
3216
 
2928
3217
    def apply_deletions(self):
2929
3218
        """Apply all marked deletions"""
2930
3219
        for path in self.pending_deletions:
2931
3220
            delete_any(path)
2932
3221
        # after apply_deletions, don't reuse _FileMover
2933
 
        past_renames = None
2934
 
        pending_deletions = None
 
3222
        self.past_renames = None
 
3223
        self.pending_deletions = None
 
3224
 
 
3225
 
 
3226
def link_tree(target_tree, source_tree):
 
3227
    """Where possible, hard-link files in a tree to those in another tree.
 
3228
 
 
3229
    :param target_tree: Tree to change
 
3230
    :param source_tree: Tree to hard-link from
 
3231
    """
 
3232
    tt = TreeTransform(target_tree)
 
3233
    try:
 
3234
        for (file_id, paths, changed_content, versioned, parent, name, kind,
 
3235
             executable) in target_tree.iter_changes(source_tree,
 
3236
                                                     include_unchanged=True):
 
3237
            if changed_content:
 
3238
                continue
 
3239
            if kind != ('file', 'file'):
 
3240
                continue
 
3241
            if executable[0] != executable[1]:
 
3242
                continue
 
3243
            trans_id = tt.trans_id_tree_path(paths[1])
 
3244
            tt.delete_contents(trans_id)
 
3245
            tt.create_hardlink(source_tree.abspath(paths[0]), trans_id)
 
3246
        tt.apply()
 
3247
    finally:
 
3248
        tt.finalize()