← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

Merged aliases

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transform.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2006 Canonical Ltd
 
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
import errno
19
19
from stat import S_ISREG
20
20
 
21
 
from bzrlib.lazy_import import lazy_import
22
 
lazy_import(globals(), """
23
 
from bzrlib import (
24
 
    bzrdir,
25
 
    delta,
26
 
    errors,
27
 
    inventory
28
 
    )
29
 
""")
30
21
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
31
22
                           ReusingTransform, NotVersionedError, CantMoveRoot,
32
 
                           ExistingLimbo, ImmortalLimbo, NoFinalPath)
 
23
                           ExistingLimbo, ImmortalLimbo)
33
24
from bzrlib.inventory import InventoryEntry
34
 
from bzrlib.osutils import (file_kind, supports_executable, pathjoin, lexists,
35
 
                            delete_any)
36
 
from bzrlib.progress import DummyProgress, ProgressPhase
37
 
from bzrlib.symbol_versioning import deprecated_function, zero_fifteen, \
38
 
        zero_nineteen
 
25
from bzrlib.osutils import file_kind, supports_executable, pathjoin
 
26
from bzrlib.progress import DummyProgress
39
27
from bzrlib.trace import mutter, warning
40
 
from bzrlib import tree
41
 
import bzrlib.ui
42
 
import bzrlib.urlutils as urlutils
43
28
 
44
29
 
45
30
ROOT_PARENT = "root-parent"
51
36
    map[key] = value
52
37
 
53
38
 
54
 
class _TransformResults(object):
55
 
    def __init__(self, modified_paths, rename_count):
56
 
        object.__init__(self)
57
 
        self.modified_paths = modified_paths
58
 
        self.rename_count = rename_count
59
 
 
60
 
 
61
39
class TreeTransform(object):
62
40
    """Represent a tree transformation.
63
41
    
64
42
    This object is designed to support incremental generation of the transform,
65
 
    in any order.
66
 
 
67
 
    However, it gives optimum performance when parent directories are created
68
 
    before their contents.  The transform is then able to put child files
69
 
    directly in their parent directory, avoiding later renames.
 
43
    in any order.  
70
44
    
71
45
    It is easy to produce malformed transforms, but they are generally
72
46
    harmless.  Attempting to apply a malformed transform will cause an
88
62
     * set_executability
89
63
    """
90
64
    def __init__(self, tree, pb=DummyProgress()):
91
 
        """Note: a tree_write lock is taken on the tree.
 
65
        """Note: a write lock is taken on the tree.
92
66
        
93
 
        Use TreeTransform.finalize() to release the lock (can be omitted if
94
 
        TreeTransform.apply() called).
 
67
        Use TreeTransform.finalize() to release the lock
95
68
        """
96
69
        object.__init__(self)
97
70
        self._tree = tree
98
 
        self._tree.lock_tree_write()
 
71
        self._tree.lock_write()
99
72
        try:
100
73
            control_files = self._tree._control_files
101
 
            self._limbodir = urlutils.local_path_from_url(
102
 
                control_files.controlfilename('limbo'))
 
74
            self._limbodir = control_files.controlfilename('limbo')
103
75
            try:
104
76
                os.mkdir(self._limbodir)
105
77
            except OSError, e:
113
85
        self._new_name = {}
114
86
        self._new_parent = {}
115
87
        self._new_contents = {}
116
 
        # A mapping of transform ids to their limbo filename
117
 
        self._limbo_files = {}
118
 
        # A mapping of transform ids to a set of the transform ids of children
119
 
        # that their limbo directory has
120
 
        self._limbo_children = {}
121
 
        # Map transform ids to maps of child filename to child transform id
122
 
        self._limbo_children_names = {}
123
 
        # List of transform ids that need to be renamed from limbo into place
124
 
        self._needs_rename = set()
125
88
        self._removed_contents = set()
126
89
        self._new_executability = {}
127
 
        self._new_reference_revision = {}
128
90
        self._new_id = {}
129
91
        self._non_present_ids = {}
130
92
        self._r_new_id = {}
131
93
        self._removed_id = set()
132
94
        self._tree_path_ids = {}
133
95
        self._tree_id_paths = {}
134
 
        # Cache of realpath results, to speed up canonical_path
135
 
        self._realpaths = {}
136
 
        # Cache of relpath results, to speed up canonical_path
137
 
        self._relpaths = {}
138
96
        self._new_root = self.trans_id_tree_file_id(tree.get_root_id())
139
97
        self.__done = False
140
98
        self._pb = pb
141
 
        self.rename_count = 0
142
99
 
143
100
    def __get_root(self):
144
101
        return self._new_root
146
103
    root = property(__get_root)
147
104
 
148
105
    def finalize(self):
149
 
        """Release the working tree lock, if held, clean up limbo dir.
150
 
 
151
 
        This is required if apply has not been invoked, but can be invoked
152
 
        even after apply.
153
 
        """
 
106
        """Release the working tree lock, if held, clean up limbo dir."""
154
107
        if self._tree is None:
155
108
            return
156
109
        try:
157
 
            entries = [(self._limbo_name(t), t, k) for t, k in
158
 
                       self._new_contents.iteritems()]
159
 
            entries.sort(reverse=True)
160
 
            for path, trans_id, kind in entries:
 
110
            for trans_id, kind in self._new_contents.iteritems():
 
111
                path = self._limbo_name(trans_id)
161
112
                if kind == "directory":
162
113
                    os.rmdir(path)
163
114
                else:
188
139
        """Change the path that is assigned to a transaction id."""
189
140
        if trans_id == self._new_root:
190
141
            raise CantMoveRoot
191
 
        previous_parent = self._new_parent.get(trans_id)
192
 
        previous_name = self._new_name.get(trans_id)
193
142
        self._new_name[trans_id] = name
194
143
        self._new_parent[trans_id] = parent
195
 
        if (trans_id in self._limbo_files and
196
 
            trans_id not in self._needs_rename):
197
 
            self._rename_in_limbo([trans_id])
198
 
            self._limbo_children[previous_parent].remove(trans_id)
199
 
            del self._limbo_children_names[previous_parent][previous_name]
200
 
 
201
 
    def _rename_in_limbo(self, trans_ids):
202
 
        """Fix limbo names so that the right final path is produced.
203
 
 
204
 
        This means we outsmarted ourselves-- we tried to avoid renaming
205
 
        these files later by creating them with their final names in their
206
 
        final parents.  But now the previous name or parent is no longer
207
 
        suitable, so we have to rename them.
208
 
 
209
 
        Even for trans_ids that have no new contents, we must remove their
210
 
        entries from _limbo_files, because they are now stale.
211
 
        """
212
 
        for trans_id in trans_ids:
213
 
            old_path = self._limbo_files.pop(trans_id)
214
 
            if trans_id not in self._new_contents:
215
 
                continue
216
 
            new_path = self._limbo_name(trans_id)
217
 
            os.rename(old_path, new_path)
218
144
 
219
145
    def adjust_root_path(self, name, parent):
220
146
        """Emulate moving the root by moving all children, instead.
277
203
    def canonical_path(self, path):
278
204
        """Get the canonical tree-relative path"""
279
205
        # don't follow final symlinks
280
 
        abs = self._tree.abspath(path)
281
 
        if abs in self._relpaths:
282
 
            return self._relpaths[abs]
283
 
        dirname, basename = os.path.split(abs)
284
 
        if dirname not in self._realpaths:
285
 
            self._realpaths[dirname] = os.path.realpath(dirname)
286
 
        dirname = self._realpaths[dirname]
287
 
        abs = pathjoin(dirname, basename)
288
 
        if dirname in self._relpaths:
289
 
            relpath = pathjoin(self._relpaths[dirname], basename)
290
 
            relpath = relpath.rstrip('/\\')
291
 
        else:
292
 
            relpath = self._tree.relpath(abs)
293
 
        self._relpaths[abs] = relpath
294
 
        return relpath
 
206
        dirname, basename = os.path.split(self._tree.abspath(path))
 
207
        dirname = os.path.realpath(dirname)
 
208
        return self._tree.relpath(pathjoin(dirname, basename))
295
209
 
296
210
    def trans_id_tree_path(self, path):
297
211
        """Determine (and maybe set) the transaction ID for a tree path."""
319
233
        New file takes the permissions of any existing file with that id,
320
234
        unless mode_id is specified.
321
235
        """
322
 
        name = self._limbo_name(trans_id)
323
 
        f = open(name, 'wb')
324
 
        try:
325
 
            try:
326
 
                unique_add(self._new_contents, trans_id, 'file')
327
 
            except:
328
 
                # Clean up the file, it never got registered so
329
 
                # TreeTransform.finalize() won't clean it up.
330
 
                f.close()
331
 
                os.unlink(name)
332
 
                raise
333
 
 
334
 
            f.writelines(contents)
335
 
        finally:
336
 
            f.close()
 
236
        f = file(self._limbo_name(trans_id), 'wb')
 
237
        unique_add(self._new_contents, trans_id, 'file')
 
238
        for segment in contents:
 
239
            f.write(segment)
 
240
        f.close()
337
241
        self._set_mode(trans_id, mode_id, S_ISREG)
338
242
 
339
243
    def _set_mode(self, trans_id, mode_id, typefunc):
349
253
        except KeyError:
350
254
            return
351
255
        try:
352
 
            mode = os.stat(self._tree.abspath(old_path)).st_mode
 
256
            mode = os.stat(old_path).st_mode
353
257
        except OSError, e:
354
258
            if e.errno == errno.ENOENT:
355
259
                return
375
279
        os.symlink(target, self._limbo_name(trans_id))
376
280
        unique_add(self._new_contents, trans_id, 'symlink')
377
281
 
 
282
    @staticmethod
 
283
    def delete_any(full_path):
 
284
        """Delete a file or directory."""
 
285
        try:
 
286
            os.unlink(full_path)
 
287
        except OSError, e:
 
288
        # We may be renaming a dangling inventory id
 
289
            if e.errno not in (errno.EISDIR, errno.EACCES, errno.EPERM):
 
290
                raise
 
291
            os.rmdir(full_path)
 
292
 
378
293
    def cancel_creation(self, trans_id):
379
294
        """Cancel the creation of new file contents."""
380
295
        del self._new_contents[trans_id]
381
 
        children = self._limbo_children.get(trans_id)
382
 
        # if this is a limbo directory with children, move them before removing
383
 
        # the directory
384
 
        if children is not None:
385
 
            self._rename_in_limbo(children)
386
 
            del self._limbo_children[trans_id]
387
 
            del self._limbo_children_names[trans_id]
388
 
        delete_any(self._limbo_name(trans_id))
 
296
        self.delete_any(self._limbo_name(trans_id))
389
297
 
390
298
    def delete_contents(self, trans_id):
391
299
        """Schedule the contents of a path entry for deletion"""
414
322
        else:
415
323
            unique_add(self._new_executability, trans_id, executability)
416
324
 
417
 
    def set_tree_reference(self, revision_id, trans_id):
418
 
        """Set the reference associated with a directory"""
419
 
        unique_add(self._new_reference_revision, trans_id, revision_id)
420
 
 
421
325
    def version_file(self, file_id, trans_id):
422
326
        """Schedule a file to become versioned."""
423
327
        assert file_id is not None
525
429
        try:
526
430
            return self._new_name[trans_id]
527
431
        except KeyError:
528
 
            try:
529
 
                return os.path.basename(self._tree_id_paths[trans_id])
530
 
            except KeyError:
531
 
                raise NoFinalPath(trans_id, self)
 
432
            return os.path.basename(self._tree_id_paths[trans_id])
532
433
 
533
 
    def by_parent(self):
 
434
    def _by_parent(self):
534
435
        """Return a map of parent: children for known parents.
535
436
        
536
437
        Only new paths and parents of tree files with assigned ids are used.
547
448
 
548
449
    def path_changed(self, trans_id):
549
450
        """Return True if a trans_id's path has changed."""
550
 
        return (trans_id in self._new_name) or (trans_id in self._new_parent)
551
 
 
552
 
    def new_contents(self, trans_id):
553
 
        return (trans_id in self._new_contents)
 
451
        return trans_id in self._new_name or trans_id in self._new_parent
554
452
 
555
453
    def find_conflicts(self):
556
454
        """Find any violations of inventory or filesystem invariants"""
560
458
        # ensure all children of all existent parents are known
561
459
        # all children of non-existent parents are known, by definition.
562
460
        self._add_tree_children()
563
 
        by_parent = self.by_parent()
 
461
        by_parent = self._by_parent()
564
462
        conflicts.extend(self._unversioned_parents(by_parent))
565
463
        conflicts.extend(self._parent_loops())
566
464
        conflicts.extend(self._duplicate_entries(by_parent))
577
475
        Active parents are those which gain children, and those which are
578
476
        removed.  This is a necessary first step in detecting conflicts.
579
477
        """
580
 
        parents = self.by_parent().keys()
 
478
        parents = self._by_parent().keys()
581
479
        parents.extend([t for t in self._removed_contents if 
582
480
                        self.tree_kind(t) == 'directory'])
583
481
        for trans_id in self._removed_id:
584
482
            file_id = self.tree_file_id(trans_id)
585
 
            if self._tree.inventory[file_id].kind == 'directory':
 
483
            if self._tree.inventory[file_id].kind in ('directory', 
 
484
                                                      'root_directory'):
586
485
                parents.append(trans_id)
587
486
 
588
487
        for parent_id in parents:
608
507
                continue
609
508
            yield self.trans_id_tree_path(childpath)
610
509
 
611
 
    def has_named_child(self, by_parent, parent_id, name):
612
 
        try:
613
 
            children = by_parent[parent_id]
614
 
        except KeyError:
615
 
            children = []
616
 
        for child in children:
617
 
            if self.final_name(child) == name:
618
 
                return True
619
 
        try:
620
 
            path = self._tree_id_paths[parent_id]
621
 
        except KeyError:
622
 
            return False
623
 
        childpath = joinpath(path, name)
624
 
        child_id = self._tree_path_ids.get(childpath)
625
 
        if child_id is None:
626
 
            return lexists(self._tree.abspath(childpath))
627
 
        else:
628
 
            if self.final_parent(child_id) != parent_id:
629
 
                return False
630
 
            if child_id in self._removed_contents:
631
 
                # XXX What about dangling file-ids?
632
 
                return False
633
 
            else:
634
 
                return True
635
 
 
636
510
    def _parent_loops(self):
637
511
        """No entry should be its own ancestor"""
638
512
        conflicts = []
641
515
            parent_id = trans_id
642
516
            while parent_id is not ROOT_PARENT:
643
517
                seen.add(parent_id)
644
 
                try:
645
 
                    parent_id = self.final_parent(parent_id)
646
 
                except KeyError:
647
 
                    break
 
518
                parent_id = self.final_parent(parent_id)
648
519
                if parent_id == trans_id:
649
520
                    conflicts.append(('parent loop', trans_id))
650
521
                if parent_id in seen:
718
589
    def _duplicate_entries(self, by_parent):
719
590
        """No directory may have two entries with the same name."""
720
591
        conflicts = []
721
 
        if (self._new_name, self._new_parent) == ({}, {}):
722
 
            return conflicts
723
592
        for children in by_parent.itervalues():
724
593
            name_ids = [(self.final_name(t), t) for t in children]
725
594
            name_ids.sort()
726
595
            last_name = None
727
596
            last_trans_id = None
728
597
            for name, trans_id in name_ids:
729
 
                try:
730
 
                    kind = self.final_kind(trans_id)
731
 
                except NoSuchFile:
732
 
                    kind = None
733
 
                file_id = self.final_file_id(trans_id)
734
 
                if kind is None and file_id is None:
735
 
                    continue
736
598
                if name == last_name:
737
599
                    conflicts.append(('duplicate', last_trans_id, trans_id,
738
600
                    name))
786
648
            return True
787
649
        return False
788
650
            
789
 
    def apply(self, no_conflicts=False):
 
651
    def apply(self):
790
652
        """Apply all changes to the inventory and filesystem.
791
653
        
792
654
        If filesystem or inventory conflicts are present, MalformedTransform
793
655
        will be thrown.
794
 
 
795
 
        If apply succeeds, finalize is not necessary.
796
 
 
797
 
        :param no_conflicts: if True, the caller guarantees there are no
798
 
            conflicts, so no check is made.
799
656
        """
800
 
        if not no_conflicts:
801
 
            conflicts = self.find_conflicts()
802
 
            if len(conflicts) != 0:
803
 
                raise MalformedTransform(conflicts=conflicts)
 
657
        conflicts = self.find_conflicts()
 
658
        if len(conflicts) != 0:
 
659
            raise MalformedTransform(conflicts=conflicts)
 
660
        limbo_inv = {}
804
661
        inv = self._tree.inventory
805
 
        inventory_delta = []
806
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
807
 
        try:
808
 
            child_pb.update('Apply phase', 0, 2)
809
 
            self._apply_removals(inv, inventory_delta)
810
 
            child_pb.update('Apply phase', 1, 2)
811
 
            modified_paths = self._apply_insertions(inv, inventory_delta)
812
 
        finally:
813
 
            child_pb.finished()
814
 
        self._tree.apply_inventory_delta(inventory_delta)
 
662
        self._apply_removals(inv, limbo_inv)
 
663
        self._apply_insertions(inv, limbo_inv)
 
664
        self._tree._write_inventory(inv)
815
665
        self.__done = True
816
666
        self.finalize()
817
 
        return _TransformResults(modified_paths, self.rename_count)
818
667
 
819
668
    def _limbo_name(self, trans_id):
820
669
        """Generate the limbo name of a file"""
821
 
        limbo_name = self._limbo_files.get(trans_id)
822
 
        if limbo_name is not None:
823
 
            return limbo_name
824
 
        parent = self._new_parent.get(trans_id)
825
 
        # if the parent directory is already in limbo (e.g. when building a
826
 
        # tree), choose a limbo name inside the parent, to reduce further
827
 
        # renames.
828
 
        use_direct_path = False
829
 
        if self._new_contents.get(parent) == 'directory':
830
 
            filename = self._new_name.get(trans_id)
831
 
            if filename is not None:
832
 
                if parent not in self._limbo_children:
833
 
                    self._limbo_children[parent] = set()
834
 
                    self._limbo_children_names[parent] = {}
835
 
                    use_direct_path = True
836
 
                # the direct path can only be used if no other file has
837
 
                # already taken this pathname, i.e. if the name is unused, or
838
 
                # if it is already associated with this trans_id.
839
 
                elif (self._limbo_children_names[parent].get(filename)
840
 
                      in (trans_id, None)):
841
 
                    use_direct_path = True
842
 
        if use_direct_path:
843
 
            limbo_name = pathjoin(self._limbo_files[parent], filename)
844
 
            self._limbo_children[parent].add(trans_id)
845
 
            self._limbo_children_names[parent][filename] = trans_id
846
 
        else:
847
 
            limbo_name = pathjoin(self._limbodir, trans_id)
848
 
            self._needs_rename.add(trans_id)
849
 
        self._limbo_files[trans_id] = limbo_name
850
 
        return limbo_name
 
670
        return pathjoin(self._limbodir, trans_id)
851
671
 
852
 
    def _apply_removals(self, inv, inventory_delta):
 
672
    def _apply_removals(self, inv, limbo_inv):
853
673
        """Perform tree operations that remove directory/inventory names.
854
674
        
855
675
        That is, delete files that are to be deleted, and put any files that
858
678
        """
859
679
        tree_paths = list(self._tree_path_ids.iteritems())
860
680
        tree_paths.sort(reverse=True)
861
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
862
 
        try:
863
 
            for num, data in enumerate(tree_paths):
864
 
                path, trans_id = data
865
 
                child_pb.update('removing file', num, len(tree_paths))
866
 
                full_path = self._tree.abspath(path)
867
 
                if trans_id in self._removed_contents:
868
 
                    delete_any(full_path)
869
 
                elif trans_id in self._new_name or trans_id in \
870
 
                    self._new_parent:
871
 
                    try:
872
 
                        os.rename(full_path, self._limbo_name(trans_id))
873
 
                    except OSError, e:
874
 
                        if e.errno != errno.ENOENT:
875
 
                            raise
876
 
                    else:
877
 
                        self.rename_count += 1
878
 
                if trans_id in self._removed_id:
879
 
                    if trans_id == self._new_root:
880
 
                        file_id = self._tree.inventory.root.file_id
881
 
                    else:
882
 
                        file_id = self.tree_file_id(trans_id)
883
 
                    assert file_id is not None
884
 
                    inventory_delta.append((path, None, file_id, None))
885
 
        finally:
886
 
            child_pb.finished()
 
681
        for num, data in enumerate(tree_paths):
 
682
            path, trans_id = data
 
683
            self._pb.update('removing file', num+1, len(tree_paths))
 
684
            full_path = self._tree.abspath(path)
 
685
            if trans_id in self._removed_contents:
 
686
                self.delete_any(full_path)
 
687
            elif trans_id in self._new_name or trans_id in self._new_parent:
 
688
                try:
 
689
                    os.rename(full_path, self._limbo_name(trans_id))
 
690
                except OSError, e:
 
691
                    if e.errno != errno.ENOENT:
 
692
                        raise
 
693
            if trans_id in self._removed_id:
 
694
                if trans_id == self._new_root:
 
695
                    file_id = self._tree.inventory.root.file_id
 
696
                else:
 
697
                    file_id = self.tree_file_id(trans_id)
 
698
                del inv[file_id]
 
699
            elif trans_id in self._new_name or trans_id in self._new_parent:
 
700
                file_id = self.tree_file_id(trans_id)
 
701
                if file_id is not None:
 
702
                    limbo_inv[trans_id] = inv[file_id]
 
703
                    del inv[file_id]
 
704
        self._pb.clear()
887
705
 
888
 
    def _apply_insertions(self, inv, inventory_delta):
 
706
    def _apply_insertions(self, inv, limbo_inv):
889
707
        """Perform tree operations that insert directory/inventory names.
890
708
        
891
709
        That is, create any files that need to be created, and restore from
893
711
        parent-to-child order.
894
712
        """
895
713
        new_paths = self.new_paths()
896
 
        modified_paths = []
897
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
898
 
        try:
899
 
            for num, (path, trans_id) in enumerate(new_paths):
900
 
                new_entry = None
901
 
                child_pb.update('adding file', num, len(new_paths))
 
714
        for num, (path, trans_id) in enumerate(new_paths):
 
715
            self._pb.update('adding file', num+1, len(new_paths))
 
716
            try:
 
717
                kind = self._new_contents[trans_id]
 
718
            except KeyError:
 
719
                kind = contents = None
 
720
            if trans_id in self._new_contents or self.path_changed(trans_id):
 
721
                full_path = self._tree.abspath(path)
902
722
                try:
903
 
                    kind = self._new_contents[trans_id]
904
 
                except KeyError:
905
 
                    kind = contents = None
906
 
                if trans_id in self._new_contents or \
907
 
                    self.path_changed(trans_id):
908
 
                    full_path = self._tree.abspath(path)
909
 
                    if trans_id in self._needs_rename:
910
 
                        try:
911
 
                            os.rename(self._limbo_name(trans_id), full_path)
912
 
                        except OSError, e:
913
 
                            # We may be renaming a dangling inventory id
914
 
                            if e.errno != errno.ENOENT:
915
 
                                raise
916
 
                        else:
917
 
                            self.rename_count += 1
918
 
                    if trans_id in self._new_contents:
919
 
                        modified_paths.append(full_path)
920
 
                        del self._new_contents[trans_id]
921
 
 
922
 
                if trans_id in self._new_id:
923
 
                    if kind is None:
924
 
                        kind = file_kind(self._tree.abspath(path))
925
 
                    if trans_id in self._new_reference_revision:
926
 
                        new_entry = inventory.TreeReference(
927
 
                            self._new_id[trans_id],
928
 
                            self._new_name[trans_id], 
929
 
                            self.final_file_id(self._new_parent[trans_id]),
930
 
                            None, self._new_reference_revision[trans_id])
931
 
                    else:
932
 
                        new_entry = inventory.make_entry(kind,
933
 
                            self.final_name(trans_id),
934
 
                            self.final_file_id(self.final_parent(trans_id)),
935
 
                            self._new_id[trans_id])
936
 
                else:
937
 
                    if trans_id in self._new_name or trans_id in\
938
 
                        self._new_parent or\
939
 
                        trans_id in self._new_executability:
940
 
                        file_id = self.final_file_id(trans_id)
941
 
                        if file_id is not None:
942
 
                            entry = inv[file_id]
943
 
                            new_entry = entry.copy()
944
 
 
945
 
                    if trans_id in self._new_name or trans_id in\
946
 
                        self._new_parent:
947
 
                            if new_entry is not None:
948
 
                                new_entry.name = self.final_name(trans_id)
949
 
                                parent = self.final_parent(trans_id)
950
 
                                parent_id = self.final_file_id(parent)
951
 
                                new_entry.parent_id = parent_id
952
 
 
953
 
                if trans_id in self._new_executability:
954
 
                    self._set_executability(path, new_entry, trans_id)
955
 
                if new_entry is not None:
956
 
                    if new_entry.file_id in inv:
957
 
                        old_path = inv.id2path(new_entry.file_id)
958
 
                    else:
959
 
                        old_path = None
960
 
                    inventory_delta.append((old_path, path,
961
 
                                            new_entry.file_id,
962
 
                                            new_entry))
963
 
        finally:
964
 
            child_pb.finished()
965
 
        return modified_paths
966
 
 
967
 
    def _set_executability(self, path, entry, trans_id):
 
723
                    os.rename(self._limbo_name(trans_id), full_path)
 
724
                except OSError, e:
 
725
                    # We may be renaming a dangling inventory id
 
726
                    if e.errno != errno.ENOENT:
 
727
                        raise
 
728
                if trans_id in self._new_contents:
 
729
                    del self._new_contents[trans_id]
 
730
 
 
731
            if trans_id in self._new_id:
 
732
                if kind is None:
 
733
                    kind = file_kind(self._tree.abspath(path))
 
734
                inv.add_path(path, kind, self._new_id[trans_id])
 
735
            elif trans_id in self._new_name or trans_id in self._new_parent:
 
736
                entry = limbo_inv.get(trans_id)
 
737
                if entry is not None:
 
738
                    entry.name = self.final_name(trans_id)
 
739
                    parent_path = os.path.dirname(path)
 
740
                    entry.parent_id = self._tree.inventory.path2id(parent_path)
 
741
                    inv.add(entry)
 
742
 
 
743
            # requires files and inventory entries to be in place
 
744
            if trans_id in self._new_executability:
 
745
                self._set_executability(path, inv, trans_id)
 
746
        self._pb.clear()
 
747
 
 
748
    def _set_executability(self, path, inv, trans_id):
968
749
        """Set the executability of versioned files """
 
750
        file_id = inv.path2id(path)
969
751
        new_executability = self._new_executability[trans_id]
970
 
        entry.executable = new_executability
 
752
        inv[file_id].executable = new_executability
971
753
        if supports_executable():
972
754
            abspath = self._tree.abspath(path)
973
755
            current_mode = os.stat(abspath).st_mode
999
781
        parent_id is the transaction id of the parent directory of the file.
1000
782
        contents is an iterator of bytestrings, which will be used to produce
1001
783
        the file.
1002
 
        :param file_id: The inventory ID of the file, if it is to be versioned.
1003
 
        :param executable: Only valid when a file_id has been supplied.
 
784
        file_id is the inventory ID of the file, if it is to be versioned.
1004
785
        """
1005
786
        trans_id = self._new_entry(name, parent_id, file_id)
1006
 
        # TODO: rather than scheduling a set_executable call,
1007
 
        # have create_file create the file with the right mode.
1008
787
        self.create_file(contents, trans_id)
1009
788
        if executable is not None:
1010
789
            self.set_executability(executable, trans_id)
1034
813
        self.create_symlink(target, trans_id)
1035
814
        return trans_id
1036
815
 
1037
 
    def _affected_ids(self):
1038
 
        """Return the set of transform ids affected by the transform"""
1039
 
        trans_ids = set(self._removed_id)
1040
 
        trans_ids.update(self._new_id.keys())
1041
 
        trans_ids.update(self._removed_contents)
1042
 
        trans_ids.update(self._new_contents.keys())
1043
 
        trans_ids.update(self._new_executability.keys())
1044
 
        trans_ids.update(self._new_name.keys())
1045
 
        trans_ids.update(self._new_parent.keys())
1046
 
        return trans_ids
1047
 
 
1048
 
    def _get_file_id_maps(self):
1049
 
        """Return mapping of file_ids to trans_ids in the to and from states"""
1050
 
        trans_ids = self._affected_ids()
1051
 
        from_trans_ids = {}
1052
 
        to_trans_ids = {}
1053
 
        # Build up two dicts: trans_ids associated with file ids in the
1054
 
        # FROM state, vs the TO state.
1055
 
        for trans_id in trans_ids:
1056
 
            from_file_id = self.tree_file_id(trans_id)
1057
 
            if from_file_id is not None:
1058
 
                from_trans_ids[from_file_id] = trans_id
1059
 
            to_file_id = self.final_file_id(trans_id)
1060
 
            if to_file_id is not None:
1061
 
                to_trans_ids[to_file_id] = trans_id
1062
 
        return from_trans_ids, to_trans_ids
1063
 
 
1064
 
    def _from_file_data(self, from_trans_id, from_versioned, file_id):
1065
 
        """Get data about a file in the from (tree) state
1066
 
 
1067
 
        Return a (name, parent, kind, executable) tuple
1068
 
        """
1069
 
        from_path = self._tree_id_paths.get(from_trans_id)
1070
 
        if from_versioned:
1071
 
            # get data from working tree if versioned
1072
 
            from_entry = self._tree.inventory[file_id]
1073
 
            from_name = from_entry.name
1074
 
            from_parent = from_entry.parent_id
1075
 
        else:
1076
 
            from_entry = None
1077
 
            if from_path is None:
1078
 
                # File does not exist in FROM state
1079
 
                from_name = None
1080
 
                from_parent = None
1081
 
            else:
1082
 
                # File exists, but is not versioned.  Have to use path-
1083
 
                # splitting stuff
1084
 
                from_name = os.path.basename(from_path)
1085
 
                tree_parent = self.get_tree_parent(from_trans_id)
1086
 
                from_parent = self.tree_file_id(tree_parent)
1087
 
        if from_path is not None:
1088
 
            from_kind, from_executable, from_stats = \
1089
 
                self._tree._comparison_data(from_entry, from_path)
1090
 
        else:
1091
 
            from_kind = None
1092
 
            from_executable = False
1093
 
        return from_name, from_parent, from_kind, from_executable
1094
 
 
1095
 
    def _to_file_data(self, to_trans_id, from_trans_id, from_executable):
1096
 
        """Get data about a file in the to (target) state
1097
 
 
1098
 
        Return a (name, parent, kind, executable) tuple
1099
 
        """
1100
 
        to_name = self.final_name(to_trans_id)
1101
 
        try:
1102
 
            to_kind = self.final_kind(to_trans_id)
1103
 
        except NoSuchFile:
1104
 
            to_kind = None
1105
 
        to_parent = self.final_file_id(self.final_parent(to_trans_id))
1106
 
        if to_trans_id in self._new_executability:
1107
 
            to_executable = self._new_executability[to_trans_id]
1108
 
        elif to_trans_id == from_trans_id:
1109
 
            to_executable = from_executable
1110
 
        else:
1111
 
            to_executable = False
1112
 
        return to_name, to_parent, to_kind, to_executable
1113
 
 
1114
 
    def _iter_changes(self):
1115
 
        """Produce output in the same format as Tree._iter_changes.
1116
 
 
1117
 
        Will produce nonsensical results if invoked while inventory/filesystem
1118
 
        conflicts (as reported by TreeTransform.find_conflicts()) are present.
1119
 
 
1120
 
        This reads the Transform, but only reproduces changes involving a
1121
 
        file_id.  Files that are not versioned in either of the FROM or TO
1122
 
        states are not reflected.
1123
 
        """
1124
 
        final_paths = FinalPaths(self)
1125
 
        from_trans_ids, to_trans_ids = self._get_file_id_maps()
1126
 
        results = []
1127
 
        # Now iterate through all active file_ids
1128
 
        for file_id in set(from_trans_ids.keys() + to_trans_ids.keys()):
1129
 
            modified = False
1130
 
            from_trans_id = from_trans_ids.get(file_id)
1131
 
            # find file ids, and determine versioning state
1132
 
            if from_trans_id is None:
1133
 
                from_versioned = False
1134
 
                from_trans_id = to_trans_ids[file_id]
1135
 
            else:
1136
 
                from_versioned = True
1137
 
            to_trans_id = to_trans_ids.get(file_id)
1138
 
            if to_trans_id is None:
1139
 
                to_versioned = False
1140
 
                to_trans_id = from_trans_id
1141
 
            else:
1142
 
                to_versioned = True
1143
 
 
1144
 
            from_name, from_parent, from_kind, from_executable = \
1145
 
                self._from_file_data(from_trans_id, from_versioned, file_id)
1146
 
 
1147
 
            to_name, to_parent, to_kind, to_executable = \
1148
 
                self._to_file_data(to_trans_id, from_trans_id, from_executable)
1149
 
 
1150
 
            if not from_versioned:
1151
 
                from_path = None
1152
 
            else:
1153
 
                from_path = self._tree_id_paths.get(from_trans_id)
1154
 
            if not to_versioned:
1155
 
                to_path = None
1156
 
            else:
1157
 
                to_path = final_paths.get_path(to_trans_id)
1158
 
            if from_kind != to_kind:
1159
 
                modified = True
1160
 
            elif to_kind in ('file', 'symlink') and (
1161
 
                to_trans_id != from_trans_id or
1162
 
                to_trans_id in self._new_contents):
1163
 
                modified = True
1164
 
            if (not modified and from_versioned == to_versioned and
1165
 
                from_parent==to_parent and from_name == to_name and
1166
 
                from_executable == to_executable):
1167
 
                continue
1168
 
            results.append((file_id, (from_path, to_path), modified,
1169
 
                   (from_versioned, to_versioned),
1170
 
                   (from_parent, to_parent),
1171
 
                   (from_name, to_name),
1172
 
                   (from_kind, to_kind),
1173
 
                   (from_executable, to_executable)))
1174
 
        return iter(sorted(results, key=lambda x:x[1]))
1175
 
 
1176
 
 
1177
816
def joinpath(parent, child):
1178
817
    """Join tree-relative paths, handling the tree root specially"""
1179
818
    if parent is None or parent == "":
1215
854
    file_ids.sort(key=tree.id2path)
1216
855
    return file_ids
1217
856
 
1218
 
 
1219
857
def build_tree(tree, wt):
1220
 
    """Create working tree for a branch, using a TreeTransform.
1221
 
    
1222
 
    This function should be used on empty trees, having a tree root at most.
1223
 
    (see merge and revert functionality for working with existing trees)
1224
 
 
1225
 
    Existing files are handled like so:
1226
 
    
1227
 
    - Existing bzrdirs take precedence over creating new items.  They are
1228
 
      created as '%s.diverted' % name.
1229
 
    - Otherwise, if the content on disk matches the content we are building,
1230
 
      it is silently replaced.
1231
 
    - Otherwise, conflict resolution will move the old file to 'oldname.moved'.
1232
 
    """
1233
 
    wt.lock_tree_write()
1234
 
    try:
1235
 
        tree.lock_read()
1236
 
        try:
1237
 
            return _build_tree(tree, wt)
1238
 
        finally:
1239
 
            tree.unlock()
1240
 
    finally:
1241
 
        wt.unlock()
1242
 
 
1243
 
def _build_tree(tree, wt):
1244
 
    """See build_tree."""
1245
 
    if len(wt.inventory) > 1:  # more than just a root
1246
 
        raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
 
858
    """Create working tree for a branch, using a Transaction."""
1247
859
    file_trans_id = {}
1248
 
    top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1249
 
    pp = ProgressPhase("Build phase", 2, top_pb)
1250
 
    if tree.inventory.root is not None:
1251
 
        # This is kind of a hack: we should be altering the root
1252
 
        # as part of the regular tree shape diff logic.
1253
 
        # The conditional test here is to avoid doing an
1254
 
        # expensive operation (flush) every time the root id
1255
 
        # is set within the tree, nor setting the root and thus
1256
 
        # marking the tree as dirty, because we use two different
1257
 
        # idioms here: tree interfaces and inventory interfaces.
1258
 
        if wt.path2id('') != tree.inventory.root.file_id:
1259
 
            wt.set_root_id(tree.inventory.root.file_id)
1260
 
            wt.flush()
1261
860
    tt = TreeTransform(wt)
1262
 
    divert = set()
1263
861
    try:
1264
 
        pp.next_phase()
1265
 
        file_trans_id[wt.get_root_id()] = \
1266
 
            tt.trans_id_tree_file_id(wt.get_root_id())
1267
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
1268
 
        try:
1269
 
            for num, (tree_path, entry) in \
1270
 
                enumerate(tree.inventory.iter_entries_by_dir()):
1271
 
                pb.update("Building tree", num, len(tree.inventory))
1272
 
                if entry.parent_id is None:
1273
 
                    continue
1274
 
                reparent = False
1275
 
                file_id = entry.file_id
1276
 
                target_path = wt.abspath(tree_path)
1277
 
                try:
1278
 
                    kind = file_kind(target_path)
1279
 
                except NoSuchFile:
1280
 
                    pass
1281
 
                else:
1282
 
                    if kind == "directory":
1283
 
                        try:
1284
 
                            bzrdir.BzrDir.open(target_path)
1285
 
                        except errors.NotBranchError:
1286
 
                            pass
1287
 
                        else:
1288
 
                            divert.add(file_id)
1289
 
                    if (file_id not in divert and
1290
 
                        _content_match(tree, entry, file_id, kind,
1291
 
                        target_path)):
1292
 
                        tt.delete_contents(tt.trans_id_tree_path(tree_path))
1293
 
                        if kind == 'directory':
1294
 
                            reparent = True
1295
 
                if entry.parent_id not in file_trans_id:
1296
 
                    raise AssertionError(
1297
 
                        'entry %s parent id %r is not in file_trans_id %r'
1298
 
                        % (entry, entry.parent_id, file_trans_id))
1299
 
                parent_id = file_trans_id[entry.parent_id]
1300
 
                file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
1301
 
                                                      tree)
1302
 
                if reparent:
1303
 
                    new_trans_id = file_trans_id[file_id]
1304
 
                    old_parent = tt.trans_id_tree_path(tree_path)
1305
 
                    _reparent_children(tt, old_parent, new_trans_id)
1306
 
        finally:
1307
 
            pb.finished()
1308
 
        pp.next_phase()
1309
 
        divert_trans = set(file_trans_id[f] for f in divert)
1310
 
        resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
1311
 
        raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
1312
 
        conflicts = cook_conflicts(raw_conflicts, tt)
1313
 
        for conflict in conflicts:
1314
 
            warning(conflict)
1315
 
        try:
1316
 
            wt.add_conflicts(conflicts)
1317
 
        except errors.UnsupportedOperation:
1318
 
            pass
1319
 
        result = tt.apply()
 
862
        file_trans_id[wt.get_root_id()] = tt.trans_id_tree_file_id(wt.get_root_id())
 
863
        file_ids = topology_sorted_ids(tree)
 
864
        for file_id in file_ids:
 
865
            entry = tree.inventory[file_id]
 
866
            if entry.parent_id is None:
 
867
                continue
 
868
            if entry.parent_id not in file_trans_id:
 
869
                raise repr(entry.parent_id)
 
870
            parent_id = file_trans_id[entry.parent_id]
 
871
            file_trans_id[file_id] = new_by_entry(tt, entry, parent_id, tree)
 
872
        tt.apply()
1320
873
    finally:
1321
874
        tt.finalize()
1322
 
        top_pb.finished()
1323
 
    return result
1324
 
 
1325
 
 
1326
 
def _reparent_children(tt, old_parent, new_parent):
1327
 
    for child in tt.iter_tree_children(old_parent):
1328
 
        tt.adjust_path(tt.final_name(child), new_parent, child)
1329
 
 
1330
 
 
1331
 
def _content_match(tree, entry, file_id, kind, target_path):
1332
 
    if entry.kind != kind:
1333
 
        return False
1334
 
    if entry.kind == "directory":
1335
 
        return True
1336
 
    if entry.kind == "file":
1337
 
        if tree.get_file(file_id).read() == file(target_path, 'rb').read():
1338
 
            return True
1339
 
    elif entry.kind == "symlink":
1340
 
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
1341
 
            return True
1342
 
    return False
1343
 
 
1344
 
 
1345
 
def resolve_checkout(tt, conflicts, divert):
1346
 
    new_conflicts = set()
1347
 
    for c_type, conflict in ((c[0], c) for c in conflicts):
1348
 
        # Anything but a 'duplicate' would indicate programmer error
1349
 
        assert c_type == 'duplicate', c_type
1350
 
        # Now figure out which is new and which is old
1351
 
        if tt.new_contents(conflict[1]):
1352
 
            new_file = conflict[1]
1353
 
            old_file = conflict[2]
1354
 
        else:
1355
 
            new_file = conflict[2]
1356
 
            old_file = conflict[1]
1357
 
 
1358
 
        # We should only get here if the conflict wasn't completely
1359
 
        # resolved
1360
 
        final_parent = tt.final_parent(old_file)
1361
 
        if new_file in divert:
1362
 
            new_name = tt.final_name(old_file)+'.diverted'
1363
 
            tt.adjust_path(new_name, final_parent, new_file)
1364
 
            new_conflicts.add((c_type, 'Diverted to',
1365
 
                               new_file, old_file))
1366
 
        else:
1367
 
            new_name = tt.final_name(old_file)+'.moved'
1368
 
            tt.adjust_path(new_name, final_parent, old_file)
1369
 
            new_conflicts.add((c_type, 'Moved existing file to',
1370
 
                               old_file, new_file))
1371
 
    return new_conflicts
1372
 
 
1373
875
 
1374
876
def new_by_entry(tt, entry, parent_id, tree):
1375
877
    """Create a new file according to its inventory entry"""
1380
882
        executable = tree.is_executable(entry.file_id)
1381
883
        return tt.new_file(name, parent_id, contents, entry.file_id, 
1382
884
                           executable)
1383
 
    elif kind in ('directory', 'tree-reference'):
1384
 
        trans_id = tt.new_directory(name, parent_id, entry.file_id)
1385
 
        if kind == 'tree-reference':
1386
 
            tt.set_tree_reference(entry.reference_revision, trans_id)
1387
 
        return trans_id 
 
885
    elif kind == 'directory':
 
886
        return tt.new_directory(name, parent_id, entry.file_id)
1388
887
    elif kind == 'symlink':
1389
888
        target = tree.get_symlink_target(entry.file_id)
1390
889
        return tt.new_symlink(name, parent_id, target, entry.file_id)
1391
 
    else:
1392
 
        raise errors.BadFileKindError(name, kind)
1393
890
 
1394
891
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
1395
892
    """Create new file contents according to an inventory entry."""
1396
893
    if entry.kind == "file":
1397
 
        if lines is None:
 
894
        if lines == None:
1398
895
            lines = tree.get_file(entry.file_id).readlines()
1399
896
        tt.create_file(lines, trans_id, mode_id=mode_id)
1400
897
    elif entry.kind == "symlink":
1408
905
        tt.set_executability(entry.executable, trans_id)
1409
906
 
1410
907
 
1411
 
@deprecated_function(zero_fifteen)
1412
908
def find_interesting(working_tree, target_tree, filenames):
1413
 
    """Find the ids corresponding to specified filenames.
1414
 
    
1415
 
    Deprecated: Please use tree1.paths2ids(filenames, [tree2]).
1416
 
    """
1417
 
    working_tree.lock_read()
1418
 
    try:
1419
 
        target_tree.lock_read()
1420
 
        try:
1421
 
            return working_tree.paths2ids(filenames, [target_tree])
1422
 
        finally:
1423
 
            target_tree.unlock()
1424
 
    finally:
1425
 
        working_tree.unlock()
1426
 
 
1427
 
 
1428
 
@deprecated_function(zero_nineteen)
 
909
    """Find the ids corresponding to specified filenames."""
 
910
    if not filenames:
 
911
        interesting_ids = None
 
912
    else:
 
913
        interesting_ids = set()
 
914
        for tree_path in filenames:
 
915
            for tree in (working_tree, target_tree):
 
916
                not_found = True
 
917
                file_id = tree.inventory.path2id(tree_path)
 
918
                if file_id is not None:
 
919
                    interesting_ids.add(file_id)
 
920
                    not_found = False
 
921
                if not_found:
 
922
                    raise NotVersionedError(path=tree_path)
 
923
    return interesting_ids
 
924
 
 
925
 
1429
926
def change_entry(tt, file_id, working_tree, target_tree, 
1430
 
                 trans_id_file_id, backups, trans_id, by_parent):
 
927
                 trans_id_file_id, backups, trans_id):
1431
928
    """Replace a file_id's contents with those from a target tree."""
1432
 
    if file_id is None and target_tree is None:
1433
 
        # skip the logic altogether in the deprecation test
1434
 
        return
1435
929
    e_trans_id = trans_id_file_id(file_id)
1436
930
    entry = target_tree.inventory[file_id]
1437
931
    has_contents, contents_mod, meta_mod, = _entry_changes(file_id, entry, 
1443
937
                tt.delete_contents(e_trans_id)
1444
938
            else:
1445
939
                parent_trans_id = trans_id_file_id(entry.parent_id)
1446
 
                backup_name = get_backup_name(entry, by_parent,
1447
 
                                              parent_trans_id, tt)
1448
 
                tt.adjust_path(backup_name, parent_trans_id, e_trans_id)
 
940
                tt.adjust_path(entry.name+"~", parent_trans_id, e_trans_id)
1449
941
                tt.unversion_file(e_trans_id)
1450
942
                e_trans_id = tt.create_path(entry.name, parent_trans_id)
1451
943
                tt.version_file(file_id, e_trans_id)
1469
961
        tt.adjust_path(entry.name, parent_trans_id, e_trans_id)
1470
962
 
1471
963
 
1472
 
def get_backup_name(entry, by_parent, parent_trans_id, tt):
1473
 
    return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
1474
 
 
1475
 
 
1476
 
def _get_backup_name(name, by_parent, parent_trans_id, tt):
1477
 
    """Produce a backup-style name that appears to be available"""
1478
 
    def name_gen():
1479
 
        counter = 1
1480
 
        while True:
1481
 
            yield "%s.~%d~" % (name, counter)
1482
 
            counter += 1
1483
 
    for new_name in name_gen():
1484
 
        if not tt.has_named_child(by_parent, parent_trans_id, new_name):
1485
 
            return new_name
1486
 
 
1487
 
 
1488
964
def _entry_changes(file_id, entry, working_tree):
1489
965
    """Determine in which ways the inventory entry has changed.
1490
966
 
1497
973
    try:
1498
974
        working_kind = working_tree.kind(file_id)
1499
975
        has_contents = True
1500
 
    except NoSuchFile:
 
976
    except OSError, e:
 
977
        if e.errno != errno.ENOENT:
 
978
            raise
1501
979
        has_contents = False
1502
980
        contents_mod = True
1503
981
        meta_mod = False
1504
982
    if has_contents is True:
1505
 
        if entry.kind != working_kind:
 
983
        real_e_kind = entry.kind
 
984
        if real_e_kind == 'root_directory':
 
985
            real_e_kind = 'directory'
 
986
        if real_e_kind != working_kind:
1506
987
            contents_mod, meta_mod = True, False
1507
988
        else:
1508
989
            cur_entry._read_tree_state(working_tree.id2path(file_id), 
1512
993
    return has_contents, contents_mod, meta_mod
1513
994
 
1514
995
 
1515
 
def revert(working_tree, target_tree, filenames, backups=False,
1516
 
           pb=DummyProgress(), change_reporter=None):
 
996
def revert(working_tree, target_tree, filenames, backups=False, 
 
997
           pb=DummyProgress()):
1517
998
    """Revert a working tree's contents to those of a target tree."""
1518
 
    target_tree.lock_read()
 
999
    interesting_ids = find_interesting(working_tree, target_tree, filenames)
 
1000
    def interesting(file_id):
 
1001
        return interesting_ids is None or file_id in interesting_ids
 
1002
 
1519
1003
    tt = TreeTransform(working_tree, pb)
1520
1004
    try:
1521
 
        pp = ProgressPhase("Revert phase", 3, pb)
1522
 
        pp.next_phase()
1523
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1524
 
        try:
1525
 
            merge_modified = _alter_files(working_tree, target_tree, tt,
1526
 
                                          child_pb, filenames, backups)
1527
 
        finally:
1528
 
            child_pb.finished()
1529
 
        pp.next_phase()
1530
 
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1531
 
        try:
1532
 
            raw_conflicts = resolve_conflicts(tt, child_pb)
1533
 
        finally:
1534
 
            child_pb.finished()
1535
 
        conflicts = cook_conflicts(raw_conflicts, tt)
1536
 
        if change_reporter:
1537
 
            change_reporter = delta._ChangeReporter(
1538
 
                unversioned_filter=working_tree.is_ignored)
1539
 
            delta.report_changes(tt._iter_changes(), change_reporter)
1540
 
        for conflict in conflicts:
1541
 
            warning(conflict)
1542
 
        pp.next_phase()
 
1005
        trans_id = {}
 
1006
        def trans_id_file_id(file_id):
 
1007
            try:
 
1008
                return trans_id[file_id]
 
1009
            except KeyError:
 
1010
                return tt.trans_id_tree_file_id(file_id)
 
1011
 
 
1012
        sorted_interesting = [i for i in topology_sorted_ids(target_tree) if
 
1013
                              interesting(i)]
 
1014
        for id_num, file_id in enumerate(sorted_interesting):
 
1015
            pb.update("Reverting file", id_num+1, len(sorted_interesting))
 
1016
            if file_id not in working_tree.inventory:
 
1017
                entry = target_tree.inventory[file_id]
 
1018
                parent_id = trans_id_file_id(entry.parent_id)
 
1019
                e_trans_id = new_by_entry(tt, entry, parent_id, target_tree)
 
1020
                trans_id[file_id] = e_trans_id
 
1021
            else:
 
1022
                change_entry(tt, file_id, working_tree, target_tree, 
 
1023
                             trans_id_file_id, backups, trans_id)
 
1024
        wt_interesting = [i for i in working_tree.inventory if interesting(i)]
 
1025
        for id_num, file_id in enumerate(wt_interesting):
 
1026
            pb.update("New file check", id_num+1, len(sorted_interesting))
 
1027
            if file_id not in target_tree:
 
1028
                tt.unversion_file(tt.trans_id_tree_file_id(file_id))
 
1029
        raw_conflicts = resolve_conflicts(tt, pb)
 
1030
        for line in conflicts_strings(cook_conflicts(raw_conflicts, tt)):
 
1031
            warning(line)
1543
1032
        tt.apply()
1544
 
        working_tree.set_merge_modified(merge_modified)
1545
1033
    finally:
1546
 
        target_tree.unlock()
1547
1034
        tt.finalize()
1548
1035
        pb.clear()
1549
 
    return conflicts
1550
 
 
1551
 
 
1552
 
def _alter_files(working_tree, target_tree, tt, pb, specific_files,
1553
 
                 backups):
1554
 
    merge_modified = working_tree.merge_modified()
1555
 
    change_list = target_tree._iter_changes(working_tree,
1556
 
        specific_files=specific_files, pb=pb)
1557
 
    if target_tree.inventory.root is None:
1558
 
        skip_root = True
1559
 
    else:
1560
 
        skip_root = False
1561
 
    basis_tree = None
1562
 
    try:
1563
 
        for id_num, (file_id, path, changed_content, versioned, parent, name,
1564
 
                kind, executable) in enumerate(change_list):
1565
 
            if skip_root and file_id[0] is not None and parent[0] is None:
1566
 
                continue
1567
 
            trans_id = tt.trans_id_file_id(file_id)
1568
 
            mode_id = None
1569
 
            if changed_content:
1570
 
                keep_content = False
1571
 
                if kind[0] == 'file' and (backups or kind[1] is None):
1572
 
                    wt_sha1 = working_tree.get_file_sha1(file_id)
1573
 
                    if merge_modified.get(file_id) != wt_sha1:
1574
 
                        # acquire the basis tree lazily to prevent the
1575
 
                        # expense of accessing it when it's not needed ?
1576
 
                        # (Guessing, RBC, 200702)
1577
 
                        if basis_tree is None:
1578
 
                            basis_tree = working_tree.basis_tree()
1579
 
                            basis_tree.lock_read()
1580
 
                        if file_id in basis_tree:
1581
 
                            if wt_sha1 != basis_tree.get_file_sha1(file_id):
1582
 
                                keep_content = True
1583
 
                        elif kind[1] is None and not versioned[1]:
1584
 
                            keep_content = True
1585
 
                if kind[0] is not None:
1586
 
                    if not keep_content:
1587
 
                        tt.delete_contents(trans_id)
1588
 
                    elif kind[1] is not None:
1589
 
                        parent_trans_id = tt.trans_id_file_id(parent[0])
1590
 
                        by_parent = tt.by_parent()
1591
 
                        backup_name = _get_backup_name(name[0], by_parent,
1592
 
                                                       parent_trans_id, tt)
1593
 
                        tt.adjust_path(backup_name, parent_trans_id, trans_id)
1594
 
                        new_trans_id = tt.create_path(name[0], parent_trans_id)
1595
 
                        if versioned == (True, True):
1596
 
                            tt.unversion_file(trans_id)
1597
 
                            tt.version_file(file_id, new_trans_id)
1598
 
                        # New contents should have the same unix perms as old
1599
 
                        # contents
1600
 
                        mode_id = trans_id
1601
 
                        trans_id = new_trans_id
1602
 
                if kind[1] == 'directory':
1603
 
                    tt.create_directory(trans_id)
1604
 
                elif kind[1] == 'symlink':
1605
 
                    tt.create_symlink(target_tree.get_symlink_target(file_id),
1606
 
                                      trans_id)
1607
 
                elif kind[1] == 'file':
1608
 
                    tt.create_file(target_tree.get_file_lines(file_id),
1609
 
                                   trans_id, mode_id)
1610
 
                    if basis_tree is None:
1611
 
                        basis_tree = working_tree.basis_tree()
1612
 
                        basis_tree.lock_read()
1613
 
                    new_sha1 = target_tree.get_file_sha1(file_id)
1614
 
                    if (file_id in basis_tree and new_sha1 ==
1615
 
                        basis_tree.get_file_sha1(file_id)):
1616
 
                        if file_id in merge_modified:
1617
 
                            del merge_modified[file_id]
1618
 
                    else:
1619
 
                        merge_modified[file_id] = new_sha1
1620
 
 
1621
 
                    # preserve the execute bit when backing up
1622
 
                    if keep_content and executable[0] == executable[1]:
1623
 
                        tt.set_executability(executable[1], trans_id)
1624
 
                else:
1625
 
                    assert kind[1] is None
1626
 
            if versioned == (False, True):
1627
 
                tt.version_file(file_id, trans_id)
1628
 
            if versioned == (True, False):
1629
 
                tt.unversion_file(trans_id)
1630
 
            if (name[1] is not None and 
1631
 
                (name[0] != name[1] or parent[0] != parent[1])):
1632
 
                tt.adjust_path(
1633
 
                    name[1], tt.trans_id_file_id(parent[1]), trans_id)
1634
 
            if executable[0] != executable[1] and kind[1] == "file":
1635
 
                tt.set_executability(executable[1], trans_id)
1636
 
    finally:
1637
 
        if basis_tree is not None:
1638
 
            basis_tree.unlock()
1639
 
    return merge_modified
1640
 
 
1641
 
 
1642
 
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
 
1036
 
 
1037
 
 
1038
def resolve_conflicts(tt, pb=DummyProgress()):
1643
1039
    """Make many conflict-resolution attempts, but die if they fail"""
1644
 
    if pass_func is None:
1645
 
        pass_func = conflict_pass
1646
1040
    new_conflicts = set()
1647
1041
    try:
1648
1042
        for n in range(10):
1650
1044
            conflicts = tt.find_conflicts()
1651
1045
            if len(conflicts) == 0:
1652
1046
                return new_conflicts
1653
 
            new_conflicts.update(pass_func(tt, conflicts))
 
1047
            new_conflicts.update(conflict_pass(tt, conflicts))
1654
1048
        raise MalformedTransform(conflicts=conflicts)
1655
1049
    finally:
1656
1050
        pb.clear()
1657
1051
 
1658
1052
 
1659
 
def conflict_pass(tt, conflicts, path_tree=None):
1660
 
    """Resolve some classes of conflicts.
1661
 
 
1662
 
    :param tt: The transform to resolve conflicts in
1663
 
    :param conflicts: The conflicts to resolve
1664
 
    :param path_tree: A Tree to get supplemental paths from
1665
 
    """
 
1053
def conflict_pass(tt, conflicts):
 
1054
    """Resolve some classes of conflicts."""
1666
1055
    new_conflicts = set()
1667
1056
    for c_type, conflict in ((c[0], c) for c in conflicts):
1668
1057
        if c_type == 'duplicate id':
1694
1083
            trans_id = conflict[1]
1695
1084
            try:
1696
1085
                tt.cancel_deletion(trans_id)
1697
 
                new_conflicts.add(('deleting parent', 'Not deleting', 
1698
 
                                   trans_id))
 
1086
                new_conflicts.add((c_type, 'Not deleting', trans_id))
1699
1087
            except KeyError:
1700
1088
                tt.create_directory(trans_id)
1701
 
                new_conflicts.add((c_type, 'Created directory', trans_id))
1702
 
                try:
1703
 
                    tt.final_name(trans_id)
1704
 
                except NoFinalPath:
1705
 
                    file_id = tt.final_file_id(trans_id)
1706
 
                    entry = path_tree.inventory[file_id]
1707
 
                    parent_trans_id = tt.trans_id_file_id(entry.parent_id)
1708
 
                    tt.adjust_path(entry.name, parent_trans_id, trans_id)
 
1089
                new_conflicts.add((c_type, 'Created directory.', trans_id))
1709
1090
        elif c_type == 'unversioned parent':
1710
1091
            tt.version_file(tt.inactive_file_id(conflict[1]), conflict[1])
1711
1092
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
1712
1093
    return new_conflicts
1713
1094
 
1714
 
 
1715
1095
def cook_conflicts(raw_conflicts, tt):
1716
1096
    """Generate a list of cooked conflicts, sorted by file path"""
1717
 
    from bzrlib.conflicts import Conflict
1718
 
    conflict_iter = iter_cook_conflicts(raw_conflicts, tt)
1719
 
    return sorted(conflict_iter, key=Conflict.sort_key)
 
1097
    def key(conflict):
 
1098
        if conflict[2] is not None:
 
1099
            return conflict[2], conflict[0]
 
1100
        elif len(conflict) == 6:
 
1101
            return conflict[4], conflict[0]
 
1102
        else:
 
1103
            return None, conflict[0]
1720
1104
 
 
1105
    return sorted(list(iter_cook_conflicts(raw_conflicts, tt)), key=key)
1721
1106
 
1722
1107
def iter_cook_conflicts(raw_conflicts, tt):
1723
 
    from bzrlib.conflicts import Conflict
 
1108
    cooked_conflicts = []
1724
1109
    fp = FinalPaths(tt)
1725
1110
    for conflict in raw_conflicts:
1726
1111
        c_type = conflict[0]
1728
1113
        modified_path = fp.get_path(conflict[2])
1729
1114
        modified_id = tt.final_file_id(conflict[2])
1730
1115
        if len(conflict) == 3:
1731
 
            yield Conflict.factory(c_type, action=action, path=modified_path,
1732
 
                                     file_id=modified_id)
1733
 
             
 
1116
            yield c_type, action, modified_path, modified_id
1734
1117
        else:
1735
1118
            conflicting_path = fp.get_path(conflict[3])
1736
1119
            conflicting_id = tt.final_file_id(conflict[3])
1737
 
            yield Conflict.factory(c_type, action=action, path=modified_path,
1738
 
                                   file_id=modified_id, 
1739
 
                                   conflict_path=conflicting_path,
1740
 
                                   conflict_file_id=conflicting_id)
 
1120
            yield (c_type, action, modified_path, modified_id, 
 
1121
                   conflicting_path, conflicting_id)
 
1122
 
 
1123
 
 
1124
def conflicts_strings(conflicts):
 
1125
    """Generate strings for the provided conflicts"""
 
1126
    for conflict in conflicts:
 
1127
        conflict_type = conflict[0]
 
1128
        if conflict_type == 'text conflict':
 
1129
            yield 'Text conflict in %s' % conflict[2]
 
1130
        elif conflict_type == 'contents conflict':
 
1131
            yield 'Contents conflict in %s' % conflict[2]
 
1132
        elif conflict_type == 'path conflict':
 
1133
            yield 'Path conflict: %s / %s' % conflict[2:]
 
1134
        elif conflict_type == 'duplicate id':
 
1135
            vals = (conflict[4], conflict[1], conflict[2])
 
1136
            yield 'Conflict adding id to %s.  %s %s.' % vals
 
1137
        elif conflict_type == 'duplicate':
 
1138
            vals = (conflict[4], conflict[1], conflict[2])
 
1139
            yield 'Conflict adding file %s.  %s %s.' % vals
 
1140
        elif conflict_type == 'parent loop':
 
1141
            vals = (conflict[4], conflict[2], conflict[1])
 
1142
            yield 'Conflict moving %s into %s.  %s.' % vals
 
1143
        elif conflict_type == 'unversioned parent':
 
1144
            vals = (conflict[2], conflict[1])
 
1145
            yield 'Conflict adding versioned files to %s.  %s.' % vals
 
1146
        elif conflict_type == 'missing parent':
 
1147
            vals = (conflict[2], conflict[1])
 
1148
            yield 'Conflict adding files to %s.  %s.' % vals