← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transform.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-03-22 12:17:00 UTC
  • mfrom: (1616.1.10 bzr.mbp.integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060322121700-79ce0be81013aba1
(mbp) pycurl fixes, other fixes, weave commands, verbose commit changes from robert

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