1
# Copyright (C) 2006, 2007 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
from stat import S_ISREG
21
from bzrlib.lazy_import import lazy_import
22
lazy_import(globals(), """
30
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
31
ReusingTransform, NotVersionedError, CantMoveRoot,
32
ExistingLimbo, ImmortalLimbo, NoFinalPath)
33
from bzrlib.inventory import InventoryEntry
34
from bzrlib.osutils import (file_kind, supports_executable, pathjoin, lexists,
36
from bzrlib.progress import DummyProgress, ProgressPhase
37
from bzrlib.symbol_versioning import (
42
from bzrlib.trace import mutter, warning
43
from bzrlib import tree
45
import bzrlib.urlutils as urlutils
48
ROOT_PARENT = "root-parent"
51
def unique_add(map, key, value):
53
raise DuplicateKey(key=key)
57
class _TransformResults(object):
58
def __init__(self, modified_paths, rename_count):
60
self.modified_paths = modified_paths
61
self.rename_count = rename_count
64
class TreeTransform(object):
65
"""Represent a tree transformation.
67
This object is designed to support incremental generation of the transform,
70
However, it gives optimum performance when parent directories are created
71
before their contents. The transform is then able to put child files
72
directly in their parent directory, avoiding later renames.
74
It is easy to produce malformed transforms, but they are generally
75
harmless. Attempting to apply a malformed transform will cause an
76
exception to be raised before any modifications are made to the tree.
78
Many kinds of malformed transforms can be corrected with the
79
resolve_conflicts function. The remaining ones indicate programming error,
80
such as trying to create a file with no path.
82
Two sets of file creation methods are supplied. Convenience methods are:
87
These are composed of the low-level methods:
89
* create_file or create_directory or create_symlink
93
def __init__(self, tree, pb=DummyProgress()):
94
"""Note: a tree_write lock is taken on the tree.
96
Use TreeTransform.finalize() to release the lock (can be omitted if
97
TreeTransform.apply() called).
101
self._tree.lock_tree_write()
103
control_files = self._tree._control_files
104
self._limbodir = urlutils.local_path_from_url(
105
control_files.controlfilename('limbo'))
107
os.mkdir(self._limbodir)
109
if e.errno == errno.EEXIST:
110
raise ExistingLimbo(self._limbodir)
117
self._new_parent = {}
118
self._new_contents = {}
119
# A mapping of transform ids to their limbo filename
120
self._limbo_files = {}
121
# A mapping of transform ids to a set of the transform ids of children
122
# that their limbo directory has
123
self._limbo_children = {}
124
# Map transform ids to maps of child filename to child transform id
125
self._limbo_children_names = {}
126
# List of transform ids that need to be renamed from limbo into place
127
self._needs_rename = set()
128
self._removed_contents = set()
129
self._new_executability = {}
130
self._new_reference_revision = {}
132
self._non_present_ids = {}
134
self._removed_id = set()
135
self._tree_path_ids = {}
136
self._tree_id_paths = {}
137
# Cache of realpath results, to speed up canonical_path
139
# Cache of relpath results, to speed up canonical_path
141
self._new_root = self.trans_id_tree_file_id(tree.get_root_id())
144
self.rename_count = 0
146
def __get_root(self):
147
return self._new_root
149
root = property(__get_root)
152
"""Release the working tree lock, if held, clean up limbo dir.
154
This is required if apply has not been invoked, but can be invoked
157
if self._tree is None:
160
entries = [(self._limbo_name(t), t, k) for t, k in
161
self._new_contents.iteritems()]
162
entries.sort(reverse=True)
163
for path, trans_id, kind in entries:
164
if kind == "directory":
169
os.rmdir(self._limbodir)
171
# We don't especially care *why* the dir is immortal.
172
raise ImmortalLimbo(self._limbodir)
177
def _assign_id(self):
178
"""Produce a new tranform id"""
179
new_id = "new-%s" % self._id_number
183
def create_path(self, name, parent):
184
"""Assign a transaction id to a new path"""
185
trans_id = self._assign_id()
186
unique_add(self._new_name, trans_id, name)
187
unique_add(self._new_parent, trans_id, parent)
190
def adjust_path(self, name, parent, trans_id):
191
"""Change the path that is assigned to a transaction id."""
192
if trans_id == self._new_root:
194
previous_parent = self._new_parent.get(trans_id)
195
previous_name = self._new_name.get(trans_id)
196
self._new_name[trans_id] = name
197
self._new_parent[trans_id] = parent
198
if (trans_id in self._limbo_files and
199
trans_id not in self._needs_rename):
200
self._rename_in_limbo([trans_id])
201
self._limbo_children[previous_parent].remove(trans_id)
202
del self._limbo_children_names[previous_parent][previous_name]
204
def _rename_in_limbo(self, trans_ids):
205
"""Fix limbo names so that the right final path is produced.
207
This means we outsmarted ourselves-- we tried to avoid renaming
208
these files later by creating them with their final names in their
209
final parents. But now the previous name or parent is no longer
210
suitable, so we have to rename them.
212
Even for trans_ids that have no new contents, we must remove their
213
entries from _limbo_files, because they are now stale.
215
for trans_id in trans_ids:
216
old_path = self._limbo_files.pop(trans_id)
217
if trans_id not in self._new_contents:
219
new_path = self._limbo_name(trans_id)
220
os.rename(old_path, new_path)
222
def adjust_root_path(self, name, parent):
223
"""Emulate moving the root by moving all children, instead.
225
We do this by undoing the association of root's transaction id with the
226
current tree. This allows us to create a new directory with that
227
transaction id. We unversion the root directory and version the
228
physically new directory, and hope someone versions the tree root
231
old_root = self._new_root
232
old_root_file_id = self.final_file_id(old_root)
233
# force moving all children of root
234
for child_id in self.iter_tree_children(old_root):
235
if child_id != parent:
236
self.adjust_path(self.final_name(child_id),
237
self.final_parent(child_id), child_id)
238
file_id = self.final_file_id(child_id)
239
if file_id is not None:
240
self.unversion_file(child_id)
241
self.version_file(file_id, child_id)
243
# the physical root needs a new transaction id
244
self._tree_path_ids.pop("")
245
self._tree_id_paths.pop(old_root)
246
self._new_root = self.trans_id_tree_file_id(self._tree.get_root_id())
247
if parent == old_root:
248
parent = self._new_root
249
self.adjust_path(name, parent, old_root)
250
self.create_directory(old_root)
251
self.version_file(old_root_file_id, old_root)
252
self.unversion_file(self._new_root)
254
def trans_id_tree_file_id(self, inventory_id):
255
"""Determine the transaction id of a working tree file.
257
This reflects only files that already exist, not ones that will be
258
added by transactions.
260
path = self._tree.inventory.id2path(inventory_id)
261
return self.trans_id_tree_path(path)
263
def trans_id_file_id(self, file_id):
264
"""Determine or set the transaction id associated with a file ID.
265
A new id is only created for file_ids that were never present. If
266
a transaction has been unversioned, it is deliberately still returned.
267
(this will likely lead to an unversioned parent conflict.)
269
if file_id in self._r_new_id and self._r_new_id[file_id] is not None:
270
return self._r_new_id[file_id]
271
elif file_id in self._tree.inventory:
272
return self.trans_id_tree_file_id(file_id)
273
elif file_id in self._non_present_ids:
274
return self._non_present_ids[file_id]
276
trans_id = self._assign_id()
277
self._non_present_ids[file_id] = trans_id
280
def canonical_path(self, path):
281
"""Get the canonical tree-relative path"""
282
# don't follow final symlinks
283
abs = self._tree.abspath(path)
284
if abs in self._relpaths:
285
return self._relpaths[abs]
286
dirname, basename = os.path.split(abs)
287
if dirname not in self._realpaths:
288
self._realpaths[dirname] = os.path.realpath(dirname)
289
dirname = self._realpaths[dirname]
290
abs = pathjoin(dirname, basename)
291
if dirname in self._relpaths:
292
relpath = pathjoin(self._relpaths[dirname], basename)
293
relpath = relpath.rstrip('/\\')
295
relpath = self._tree.relpath(abs)
296
self._relpaths[abs] = relpath
299
def trans_id_tree_path(self, path):
300
"""Determine (and maybe set) the transaction ID for a tree path."""
301
path = self.canonical_path(path)
302
if path not in self._tree_path_ids:
303
self._tree_path_ids[path] = self._assign_id()
304
self._tree_id_paths[self._tree_path_ids[path]] = path
305
return self._tree_path_ids[path]
307
def get_tree_parent(self, trans_id):
308
"""Determine id of the parent in the tree."""
309
path = self._tree_id_paths[trans_id]
312
return self.trans_id_tree_path(os.path.dirname(path))
314
def create_file(self, contents, trans_id, mode_id=None):
315
"""Schedule creation of a new file.
319
Contents is an iterator of strings, all of which will be written
320
to the target destination.
322
New file takes the permissions of any existing file with that id,
323
unless mode_id is specified.
325
name = self._limbo_name(trans_id)
329
unique_add(self._new_contents, trans_id, 'file')
331
# Clean up the file, it never got registered so
332
# TreeTransform.finalize() won't clean it up.
337
f.writelines(contents)
340
self._set_mode(trans_id, mode_id, S_ISREG)
342
def _set_mode(self, trans_id, mode_id, typefunc):
343
"""Set the mode of new file contents.
344
The mode_id is the existing file to get the mode from (often the same
345
as trans_id). The operation is only performed if there's a mode match
346
according to typefunc.
351
old_path = self._tree_id_paths[mode_id]
355
mode = os.stat(self._tree.abspath(old_path)).st_mode
357
if e.errno == errno.ENOENT:
362
os.chmod(self._limbo_name(trans_id), mode)
364
def create_directory(self, trans_id):
365
"""Schedule creation of a new directory.
367
See also new_directory.
369
os.mkdir(self._limbo_name(trans_id))
370
unique_add(self._new_contents, trans_id, 'directory')
372
def create_symlink(self, target, trans_id):
373
"""Schedule creation of a new symbolic link.
375
target is a bytestring.
376
See also new_symlink.
378
os.symlink(target, self._limbo_name(trans_id))
379
unique_add(self._new_contents, trans_id, 'symlink')
381
def cancel_creation(self, trans_id):
382
"""Cancel the creation of new file contents."""
383
del self._new_contents[trans_id]
384
children = self._limbo_children.get(trans_id)
385
# if this is a limbo directory with children, move them before removing
387
if children is not None:
388
self._rename_in_limbo(children)
389
del self._limbo_children[trans_id]
390
del self._limbo_children_names[trans_id]
391
delete_any(self._limbo_name(trans_id))
393
def delete_contents(self, trans_id):
394
"""Schedule the contents of a path entry for deletion"""
395
self.tree_kind(trans_id)
396
self._removed_contents.add(trans_id)
398
def cancel_deletion(self, trans_id):
399
"""Cancel a scheduled deletion"""
400
self._removed_contents.remove(trans_id)
402
def unversion_file(self, trans_id):
403
"""Schedule a path entry to become unversioned"""
404
self._removed_id.add(trans_id)
406
def delete_versioned(self, trans_id):
407
"""Delete and unversion a versioned file"""
408
self.delete_contents(trans_id)
409
self.unversion_file(trans_id)
411
def set_executability(self, executability, trans_id):
412
"""Schedule setting of the 'execute' bit
413
To unschedule, set to None
415
if executability is None:
416
del self._new_executability[trans_id]
418
unique_add(self._new_executability, trans_id, executability)
420
def set_tree_reference(self, revision_id, trans_id):
421
"""Set the reference associated with a directory"""
422
unique_add(self._new_reference_revision, trans_id, revision_id)
424
def version_file(self, file_id, trans_id):
425
"""Schedule a file to become versioned."""
426
assert file_id is not None
427
unique_add(self._new_id, trans_id, file_id)
428
unique_add(self._r_new_id, file_id, trans_id)
430
def cancel_versioning(self, trans_id):
431
"""Undo a previous versioning of a file"""
432
file_id = self._new_id[trans_id]
433
del self._new_id[trans_id]
434
del self._r_new_id[file_id]
437
"""Determine the paths of all new and changed files"""
439
fp = FinalPaths(self)
440
for id_set in (self._new_name, self._new_parent, self._new_contents,
441
self._new_id, self._new_executability):
442
new_ids.update(id_set)
443
new_paths = [(fp.get_path(t), t) for t in new_ids]
447
def tree_kind(self, trans_id):
448
"""Determine the file kind in the working tree.
450
Raises NoSuchFile if the file does not exist
452
path = self._tree_id_paths.get(trans_id)
454
raise NoSuchFile(None)
456
return file_kind(self._tree.abspath(path))
458
if e.errno != errno.ENOENT:
461
raise NoSuchFile(path)
463
def final_kind(self, trans_id):
464
"""Determine the final file kind, after any changes applied.
466
Raises NoSuchFile if the file does not exist/has no contents.
467
(It is conceivable that a path would be created without the
468
corresponding contents insertion command)
470
if trans_id in self._new_contents:
471
return self._new_contents[trans_id]
472
elif trans_id in self._removed_contents:
473
raise NoSuchFile(None)
475
return self.tree_kind(trans_id)
477
def tree_file_id(self, trans_id):
478
"""Determine the file id associated with the trans_id in the tree"""
480
path = self._tree_id_paths[trans_id]
482
# the file is a new, unversioned file, or invalid trans_id
484
# the file is old; the old id is still valid
485
if self._new_root == trans_id:
486
return self._tree.inventory.root.file_id
487
return self._tree.inventory.path2id(path)
489
def final_file_id(self, trans_id):
490
"""Determine the file id after any changes are applied, or None.
492
None indicates that the file will not be versioned after changes are
496
# there is a new id for this file
497
assert self._new_id[trans_id] is not None
498
return self._new_id[trans_id]
500
if trans_id in self._removed_id:
502
return self.tree_file_id(trans_id)
504
def inactive_file_id(self, trans_id):
505
"""Return the inactive file_id associated with a transaction id.
506
That is, the one in the tree or in non_present_ids.
507
The file_id may actually be active, too.
509
file_id = self.tree_file_id(trans_id)
510
if file_id is not None:
512
for key, value in self._non_present_ids.iteritems():
513
if value == trans_id:
516
def final_parent(self, trans_id):
517
"""Determine the parent file_id, after any changes are applied.
519
ROOT_PARENT is returned for the tree root.
522
return self._new_parent[trans_id]
524
return self.get_tree_parent(trans_id)
526
def final_name(self, trans_id):
527
"""Determine the final filename, after all changes are applied."""
529
return self._new_name[trans_id]
532
return os.path.basename(self._tree_id_paths[trans_id])
534
raise NoFinalPath(trans_id, self)
537
"""Return a map of parent: children for known parents.
539
Only new paths and parents of tree files with assigned ids are used.
542
items = list(self._new_parent.iteritems())
543
items.extend((t, self.final_parent(t)) for t in
544
self._tree_id_paths.keys())
545
for trans_id, parent_id in items:
546
if parent_id not in by_parent:
547
by_parent[parent_id] = set()
548
by_parent[parent_id].add(trans_id)
551
def path_changed(self, trans_id):
552
"""Return True if a trans_id's path has changed."""
553
return (trans_id in self._new_name) or (trans_id in self._new_parent)
555
def new_contents(self, trans_id):
556
return (trans_id in self._new_contents)
558
def find_conflicts(self):
559
"""Find any violations of inventory or filesystem invariants"""
560
if self.__done is True:
561
raise ReusingTransform()
563
# ensure all children of all existent parents are known
564
# all children of non-existent parents are known, by definition.
565
self._add_tree_children()
566
by_parent = self.by_parent()
567
conflicts.extend(self._unversioned_parents(by_parent))
568
conflicts.extend(self._parent_loops())
569
conflicts.extend(self._duplicate_entries(by_parent))
570
conflicts.extend(self._duplicate_ids())
571
conflicts.extend(self._parent_type_conflicts(by_parent))
572
conflicts.extend(self._improper_versioning())
573
conflicts.extend(self._executability_conflicts())
574
conflicts.extend(self._overwrite_conflicts())
577
def _add_tree_children(self):
578
"""Add all the children of all active parents to the known paths.
580
Active parents are those which gain children, and those which are
581
removed. This is a necessary first step in detecting conflicts.
583
parents = self.by_parent().keys()
584
parents.extend([t for t in self._removed_contents if
585
self.tree_kind(t) == 'directory'])
586
for trans_id in self._removed_id:
587
file_id = self.tree_file_id(trans_id)
588
if self._tree.inventory[file_id].kind == 'directory':
589
parents.append(trans_id)
591
for parent_id in parents:
592
# ensure that all children are registered with the transaction
593
list(self.iter_tree_children(parent_id))
595
def iter_tree_children(self, parent_id):
596
"""Iterate through the entry's tree children, if any"""
598
path = self._tree_id_paths[parent_id]
602
children = os.listdir(self._tree.abspath(path))
604
if e.errno != errno.ENOENT and e.errno != errno.ESRCH:
608
for child in children:
609
childpath = joinpath(path, child)
610
if self._tree.is_control_filename(childpath):
612
yield self.trans_id_tree_path(childpath)
614
def has_named_child(self, by_parent, parent_id, name):
616
children = by_parent[parent_id]
619
for child in children:
620
if self.final_name(child) == name:
623
path = self._tree_id_paths[parent_id]
626
childpath = joinpath(path, name)
627
child_id = self._tree_path_ids.get(childpath)
629
return lexists(self._tree.abspath(childpath))
631
if self.final_parent(child_id) != parent_id:
633
if child_id in self._removed_contents:
634
# XXX What about dangling file-ids?
639
def _parent_loops(self):
640
"""No entry should be its own ancestor"""
642
for trans_id in self._new_parent:
645
while parent_id is not ROOT_PARENT:
648
parent_id = self.final_parent(parent_id)
651
if parent_id == trans_id:
652
conflicts.append(('parent loop', trans_id))
653
if parent_id in seen:
657
def _unversioned_parents(self, by_parent):
658
"""If parent directories are versioned, children must be versioned."""
660
for parent_id, children in by_parent.iteritems():
661
if parent_id is ROOT_PARENT:
663
if self.final_file_id(parent_id) is not None:
665
for child_id in children:
666
if self.final_file_id(child_id) is not None:
667
conflicts.append(('unversioned parent', parent_id))
671
def _improper_versioning(self):
672
"""Cannot version a file with no contents, or a bad type.
674
However, existing entries with no contents are okay.
677
for trans_id in self._new_id.iterkeys():
679
kind = self.final_kind(trans_id)
681
conflicts.append(('versioning no contents', trans_id))
683
if not InventoryEntry.versionable_kind(kind):
684
conflicts.append(('versioning bad kind', trans_id, kind))
687
def _executability_conflicts(self):
688
"""Check for bad executability changes.
690
Only versioned files may have their executability set, because
691
1. only versioned entries can have executability under windows
692
2. only files can be executable. (The execute bit on a directory
693
does not indicate searchability)
696
for trans_id in self._new_executability:
697
if self.final_file_id(trans_id) is None:
698
conflicts.append(('unversioned executability', trans_id))
701
non_file = self.final_kind(trans_id) != "file"
705
conflicts.append(('non-file executability', trans_id))
708
def _overwrite_conflicts(self):
709
"""Check for overwrites (not permitted on Win32)"""
711
for trans_id in self._new_contents:
713
self.tree_kind(trans_id)
716
if trans_id not in self._removed_contents:
717
conflicts.append(('overwrite', trans_id,
718
self.final_name(trans_id)))
721
def _duplicate_entries(self, by_parent):
722
"""No directory may have two entries with the same name."""
724
if (self._new_name, self._new_parent) == ({}, {}):
726
for children in by_parent.itervalues():
727
name_ids = [(self.final_name(t), t) for t in children]
731
for name, trans_id in name_ids:
733
kind = self.final_kind(trans_id)
736
file_id = self.final_file_id(trans_id)
737
if kind is None and file_id is None:
739
if name == last_name:
740
conflicts.append(('duplicate', last_trans_id, trans_id,
743
last_trans_id = trans_id
746
def _duplicate_ids(self):
747
"""Each inventory id may only be used once"""
749
removed_tree_ids = set((self.tree_file_id(trans_id) for trans_id in
751
active_tree_ids = set((f for f in self._tree.inventory if
752
f not in removed_tree_ids))
753
for trans_id, file_id in self._new_id.iteritems():
754
if file_id in active_tree_ids:
755
old_trans_id = self.trans_id_tree_file_id(file_id)
756
conflicts.append(('duplicate id', old_trans_id, trans_id))
759
def _parent_type_conflicts(self, by_parent):
760
"""parents must have directory 'contents'."""
762
for parent_id, children in by_parent.iteritems():
763
if parent_id is ROOT_PARENT:
765
if not self._any_contents(children):
767
for child in children:
769
self.final_kind(child)
773
kind = self.final_kind(parent_id)
777
conflicts.append(('missing parent', parent_id))
778
elif kind != "directory":
779
conflicts.append(('non-directory parent', parent_id))
782
def _any_contents(self, trans_ids):
783
"""Return true if any of the trans_ids, will have contents."""
784
for trans_id in trans_ids:
786
kind = self.final_kind(trans_id)
792
def apply(self, no_conflicts=False):
793
"""Apply all changes to the inventory and filesystem.
795
If filesystem or inventory conflicts are present, MalformedTransform
798
If apply succeeds, finalize is not necessary.
800
:param no_conflicts: if True, the caller guarantees there are no
801
conflicts, so no check is made.
804
conflicts = self.find_conflicts()
805
if len(conflicts) != 0:
806
raise MalformedTransform(conflicts=conflicts)
807
inv = self._tree.inventory
809
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
811
child_pb.update('Apply phase', 0, 2)
812
self._apply_removals(inv, inventory_delta)
813
child_pb.update('Apply phase', 1, 2)
814
modified_paths = self._apply_insertions(inv, inventory_delta)
817
self._tree.apply_inventory_delta(inventory_delta)
820
return _TransformResults(modified_paths, self.rename_count)
822
def _limbo_name(self, trans_id):
823
"""Generate the limbo name of a file"""
824
limbo_name = self._limbo_files.get(trans_id)
825
if limbo_name is not None:
827
parent = self._new_parent.get(trans_id)
828
# if the parent directory is already in limbo (e.g. when building a
829
# tree), choose a limbo name inside the parent, to reduce further
831
use_direct_path = False
832
if self._new_contents.get(parent) == 'directory':
833
filename = self._new_name.get(trans_id)
834
if filename is not None:
835
if parent not in self._limbo_children:
836
self._limbo_children[parent] = set()
837
self._limbo_children_names[parent] = {}
838
use_direct_path = True
839
# the direct path can only be used if no other file has
840
# already taken this pathname, i.e. if the name is unused, or
841
# if it is already associated with this trans_id.
842
elif (self._limbo_children_names[parent].get(filename)
843
in (trans_id, None)):
844
use_direct_path = True
846
limbo_name = pathjoin(self._limbo_files[parent], filename)
847
self._limbo_children[parent].add(trans_id)
848
self._limbo_children_names[parent][filename] = trans_id
850
limbo_name = pathjoin(self._limbodir, trans_id)
851
self._needs_rename.add(trans_id)
852
self._limbo_files[trans_id] = limbo_name
855
def _apply_removals(self, inv, inventory_delta):
856
"""Perform tree operations that remove directory/inventory names.
858
That is, delete files that are to be deleted, and put any files that
859
need renaming into limbo. This must be done in strict child-to-parent
862
tree_paths = list(self._tree_path_ids.iteritems())
863
tree_paths.sort(reverse=True)
864
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
866
for num, data in enumerate(tree_paths):
867
path, trans_id = data
868
child_pb.update('removing file', num, len(tree_paths))
869
full_path = self._tree.abspath(path)
870
if trans_id in self._removed_contents:
871
delete_any(full_path)
872
elif trans_id in self._new_name or trans_id in \
875
os.rename(full_path, self._limbo_name(trans_id))
877
if e.errno != errno.ENOENT:
880
self.rename_count += 1
881
if trans_id in self._removed_id:
882
if trans_id == self._new_root:
883
file_id = self._tree.inventory.root.file_id
885
file_id = self.tree_file_id(trans_id)
886
assert file_id is not None
887
inventory_delta.append((path, None, file_id, None))
891
def _apply_insertions(self, inv, inventory_delta):
892
"""Perform tree operations that insert directory/inventory names.
894
That is, create any files that need to be created, and restore from
895
limbo any files that needed renaming. This must be done in strict
896
parent-to-child order.
898
new_paths = self.new_paths()
900
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
902
for num, (path, trans_id) in enumerate(new_paths):
904
child_pb.update('adding file', num, len(new_paths))
906
kind = self._new_contents[trans_id]
908
kind = contents = None
909
if trans_id in self._new_contents or \
910
self.path_changed(trans_id):
911
full_path = self._tree.abspath(path)
912
if trans_id in self._needs_rename:
914
os.rename(self._limbo_name(trans_id), full_path)
916
# We may be renaming a dangling inventory id
917
if e.errno != errno.ENOENT:
920
self.rename_count += 1
921
if trans_id in self._new_contents:
922
modified_paths.append(full_path)
923
del self._new_contents[trans_id]
925
if trans_id in self._new_id:
927
kind = file_kind(self._tree.abspath(path))
928
if trans_id in self._new_reference_revision:
929
new_entry = inventory.TreeReference(
930
self._new_id[trans_id],
931
self._new_name[trans_id],
932
self.final_file_id(self._new_parent[trans_id]),
933
None, self._new_reference_revision[trans_id])
935
new_entry = inventory.make_entry(kind,
936
self.final_name(trans_id),
937
self.final_file_id(self.final_parent(trans_id)),
938
self._new_id[trans_id])
940
if trans_id in self._new_name or trans_id in\
942
trans_id in self._new_executability:
943
file_id = self.final_file_id(trans_id)
944
if file_id is not None:
946
new_entry = entry.copy()
948
if trans_id in self._new_name or trans_id in\
950
if new_entry is not None:
951
new_entry.name = self.final_name(trans_id)
952
parent = self.final_parent(trans_id)
953
parent_id = self.final_file_id(parent)
954
new_entry.parent_id = parent_id
956
if trans_id in self._new_executability:
957
self._set_executability(path, new_entry, trans_id)
958
if new_entry is not None:
959
if new_entry.file_id in inv:
960
old_path = inv.id2path(new_entry.file_id)
963
inventory_delta.append((old_path, path,
968
return modified_paths
970
def _set_executability(self, path, entry, trans_id):
971
"""Set the executability of versioned files """
972
new_executability = self._new_executability[trans_id]
973
entry.executable = new_executability
974
if supports_executable():
975
abspath = self._tree.abspath(path)
976
current_mode = os.stat(abspath).st_mode
977
if new_executability:
980
to_mode = current_mode | (0100 & ~umask)
981
# Enable x-bit for others only if they can read it.
982
if current_mode & 0004:
983
to_mode |= 0001 & ~umask
984
if current_mode & 0040:
985
to_mode |= 0010 & ~umask
987
to_mode = current_mode & ~0111
988
os.chmod(abspath, to_mode)
990
def _new_entry(self, name, parent_id, file_id):
991
"""Helper function to create a new filesystem entry."""
992
trans_id = self.create_path(name, parent_id)
993
if file_id is not None:
994
self.version_file(file_id, trans_id)
997
def new_file(self, name, parent_id, contents, file_id=None,
999
"""Convenience method to create files.
1001
name is the name of the file to create.
1002
parent_id is the transaction id of the parent directory of the file.
1003
contents is an iterator of bytestrings, which will be used to produce
1005
:param file_id: The inventory ID of the file, if it is to be versioned.
1006
:param executable: Only valid when a file_id has been supplied.
1008
trans_id = self._new_entry(name, parent_id, file_id)
1009
# TODO: rather than scheduling a set_executable call,
1010
# have create_file create the file with the right mode.
1011
self.create_file(contents, trans_id)
1012
if executable is not None:
1013
self.set_executability(executable, trans_id)
1016
def new_directory(self, name, parent_id, file_id=None):
1017
"""Convenience method to create directories.
1019
name is the name of the directory to create.
1020
parent_id is the transaction id of the parent directory of the
1022
file_id is the inventory ID of the directory, if it is to be versioned.
1024
trans_id = self._new_entry(name, parent_id, file_id)
1025
self.create_directory(trans_id)
1028
def new_symlink(self, name, parent_id, target, file_id=None):
1029
"""Convenience method to create symbolic link.
1031
name is the name of the symlink to create.
1032
parent_id is the transaction id of the parent directory of the symlink.
1033
target is a bytestring of the target of the symlink.
1034
file_id is the inventory ID of the file, if it is to be versioned.
1036
trans_id = self._new_entry(name, parent_id, file_id)
1037
self.create_symlink(target, trans_id)
1040
def _affected_ids(self):
1041
"""Return the set of transform ids affected by the transform"""
1042
trans_ids = set(self._removed_id)
1043
trans_ids.update(self._new_id.keys())
1044
trans_ids.update(self._removed_contents)
1045
trans_ids.update(self._new_contents.keys())
1046
trans_ids.update(self._new_executability.keys())
1047
trans_ids.update(self._new_name.keys())
1048
trans_ids.update(self._new_parent.keys())
1051
def _get_file_id_maps(self):
1052
"""Return mapping of file_ids to trans_ids in the to and from states"""
1053
trans_ids = self._affected_ids()
1056
# Build up two dicts: trans_ids associated with file ids in the
1057
# FROM state, vs the TO state.
1058
for trans_id in trans_ids:
1059
from_file_id = self.tree_file_id(trans_id)
1060
if from_file_id is not None:
1061
from_trans_ids[from_file_id] = trans_id
1062
to_file_id = self.final_file_id(trans_id)
1063
if to_file_id is not None:
1064
to_trans_ids[to_file_id] = trans_id
1065
return from_trans_ids, to_trans_ids
1067
def _from_file_data(self, from_trans_id, from_versioned, file_id):
1068
"""Get data about a file in the from (tree) state
1070
Return a (name, parent, kind, executable) tuple
1072
from_path = self._tree_id_paths.get(from_trans_id)
1074
# get data from working tree if versioned
1075
from_entry = self._tree.inventory[file_id]
1076
from_name = from_entry.name
1077
from_parent = from_entry.parent_id
1080
if from_path is None:
1081
# File does not exist in FROM state
1085
# File exists, but is not versioned. Have to use path-
1087
from_name = os.path.basename(from_path)
1088
tree_parent = self.get_tree_parent(from_trans_id)
1089
from_parent = self.tree_file_id(tree_parent)
1090
if from_path is not None:
1091
from_kind, from_executable, from_stats = \
1092
self._tree._comparison_data(from_entry, from_path)
1095
from_executable = False
1096
return from_name, from_parent, from_kind, from_executable
1098
def _to_file_data(self, to_trans_id, from_trans_id, from_executable):
1099
"""Get data about a file in the to (target) state
1101
Return a (name, parent, kind, executable) tuple
1103
to_name = self.final_name(to_trans_id)
1105
to_kind = self.final_kind(to_trans_id)
1108
to_parent = self.final_file_id(self.final_parent(to_trans_id))
1109
if to_trans_id in self._new_executability:
1110
to_executable = self._new_executability[to_trans_id]
1111
elif to_trans_id == from_trans_id:
1112
to_executable = from_executable
1114
to_executable = False
1115
return to_name, to_parent, to_kind, to_executable
1117
def _iter_changes(self):
1118
"""Produce output in the same format as Tree._iter_changes.
1120
Will produce nonsensical results if invoked while inventory/filesystem
1121
conflicts (as reported by TreeTransform.find_conflicts()) are present.
1123
This reads the Transform, but only reproduces changes involving a
1124
file_id. Files that are not versioned in either of the FROM or TO
1125
states are not reflected.
1127
final_paths = FinalPaths(self)
1128
from_trans_ids, to_trans_ids = self._get_file_id_maps()
1130
# Now iterate through all active file_ids
1131
for file_id in set(from_trans_ids.keys() + to_trans_ids.keys()):
1133
from_trans_id = from_trans_ids.get(file_id)
1134
# find file ids, and determine versioning state
1135
if from_trans_id is None:
1136
from_versioned = False
1137
from_trans_id = to_trans_ids[file_id]
1139
from_versioned = True
1140
to_trans_id = to_trans_ids.get(file_id)
1141
if to_trans_id is None:
1142
to_versioned = False
1143
to_trans_id = from_trans_id
1147
from_name, from_parent, from_kind, from_executable = \
1148
self._from_file_data(from_trans_id, from_versioned, file_id)
1150
to_name, to_parent, to_kind, to_executable = \
1151
self._to_file_data(to_trans_id, from_trans_id, from_executable)
1153
if not from_versioned:
1156
from_path = self._tree_id_paths.get(from_trans_id)
1157
if not to_versioned:
1160
to_path = final_paths.get_path(to_trans_id)
1161
if from_kind != to_kind:
1163
elif to_kind in ('file', 'symlink') and (
1164
to_trans_id != from_trans_id or
1165
to_trans_id in self._new_contents):
1167
if (not modified and from_versioned == to_versioned and
1168
from_parent==to_parent and from_name == to_name and
1169
from_executable == to_executable):
1171
results.append((file_id, (from_path, to_path), modified,
1172
(from_versioned, to_versioned),
1173
(from_parent, to_parent),
1174
(from_name, to_name),
1175
(from_kind, to_kind),
1176
(from_executable, to_executable)))
1177
return iter(sorted(results, key=lambda x:x[1]))
1180
def joinpath(parent, child):
1181
"""Join tree-relative paths, handling the tree root specially"""
1182
if parent is None or parent == "":
1185
return pathjoin(parent, child)
1188
class FinalPaths(object):
1189
"""Make path calculation cheap by memoizing paths.
1191
The underlying tree must not be manipulated between calls, or else
1192
the results will likely be incorrect.
1194
def __init__(self, transform):
1195
object.__init__(self)
1196
self._known_paths = {}
1197
self.transform = transform
1199
def _determine_path(self, trans_id):
1200
if trans_id == self.transform.root:
1202
name = self.transform.final_name(trans_id)
1203
parent_id = self.transform.final_parent(trans_id)
1204
if parent_id == self.transform.root:
1207
return pathjoin(self.get_path(parent_id), name)
1209
def get_path(self, trans_id):
1210
"""Find the final path associated with a trans_id"""
1211
if trans_id not in self._known_paths:
1212
self._known_paths[trans_id] = self._determine_path(trans_id)
1213
return self._known_paths[trans_id]
1215
def topology_sorted_ids(tree):
1216
"""Determine the topological order of the ids in a tree"""
1217
file_ids = list(tree)
1218
file_ids.sort(key=tree.id2path)
1222
def build_tree(tree, wt):
1223
"""Create working tree for a branch, using a TreeTransform.
1225
This function should be used on empty trees, having a tree root at most.
1226
(see merge and revert functionality for working with existing trees)
1228
Existing files are handled like so:
1230
- Existing bzrdirs take precedence over creating new items. They are
1231
created as '%s.diverted' % name.
1232
- Otherwise, if the content on disk matches the content we are building,
1233
it is silently replaced.
1234
- Otherwise, conflict resolution will move the old file to 'oldname.moved'.
1236
wt.lock_tree_write()
1240
return _build_tree(tree, wt)
1246
def _build_tree(tree, wt):
1247
"""See build_tree."""
1248
if len(wt.inventory) > 1: # more than just a root
1249
raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
1251
top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1252
pp = ProgressPhase("Build phase", 2, top_pb)
1253
if tree.inventory.root is not None:
1254
# This is kind of a hack: we should be altering the root
1255
# as part of the regular tree shape diff logic.
1256
# The conditional test here is to avoid doing an
1257
# expensive operation (flush) every time the root id
1258
# is set within the tree, nor setting the root and thus
1259
# marking the tree as dirty, because we use two different
1260
# idioms here: tree interfaces and inventory interfaces.
1261
if wt.path2id('') != tree.inventory.root.file_id:
1262
wt.set_root_id(tree.inventory.root.file_id)
1264
tt = TreeTransform(wt)
1268
file_trans_id[wt.get_root_id()] = \
1269
tt.trans_id_tree_file_id(wt.get_root_id())
1270
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1272
for num, (tree_path, entry) in \
1273
enumerate(tree.inventory.iter_entries_by_dir()):
1274
pb.update("Building tree", num, len(tree.inventory))
1275
if entry.parent_id is None:
1278
file_id = entry.file_id
1279
target_path = wt.abspath(tree_path)
1281
kind = file_kind(target_path)
1285
if kind == "directory":
1287
bzrdir.BzrDir.open(target_path)
1288
except errors.NotBranchError:
1292
if (file_id not in divert and
1293
_content_match(tree, entry, file_id, kind,
1295
tt.delete_contents(tt.trans_id_tree_path(tree_path))
1296
if kind == 'directory':
1298
if entry.parent_id not in file_trans_id:
1299
raise AssertionError(
1300
'entry %s parent id %r is not in file_trans_id %r'
1301
% (entry, entry.parent_id, file_trans_id))
1302
parent_id = file_trans_id[entry.parent_id]
1303
file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
1306
new_trans_id = file_trans_id[file_id]
1307
old_parent = tt.trans_id_tree_path(tree_path)
1308
_reparent_children(tt, old_parent, new_trans_id)
1312
divert_trans = set(file_trans_id[f] for f in divert)
1313
resolver = lambda t, c: resolve_checkout(t, c, divert_trans)
1314
raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
1315
conflicts = cook_conflicts(raw_conflicts, tt)
1316
for conflict in conflicts:
1319
wt.add_conflicts(conflicts)
1320
except errors.UnsupportedOperation:
1329
def _reparent_children(tt, old_parent, new_parent):
1330
for child in tt.iter_tree_children(old_parent):
1331
tt.adjust_path(tt.final_name(child), new_parent, child)
1334
def _content_match(tree, entry, file_id, kind, target_path):
1335
if entry.kind != kind:
1337
if entry.kind == "directory":
1339
if entry.kind == "file":
1340
if tree.get_file(file_id).read() == file(target_path, 'rb').read():
1342
elif entry.kind == "symlink":
1343
if tree.get_symlink_target(file_id) == os.readlink(target_path):
1348
def resolve_checkout(tt, conflicts, divert):
1349
new_conflicts = set()
1350
for c_type, conflict in ((c[0], c) for c in conflicts):
1351
# Anything but a 'duplicate' would indicate programmer error
1352
assert c_type == 'duplicate', c_type
1353
# Now figure out which is new and which is old
1354
if tt.new_contents(conflict[1]):
1355
new_file = conflict[1]
1356
old_file = conflict[2]
1358
new_file = conflict[2]
1359
old_file = conflict[1]
1361
# We should only get here if the conflict wasn't completely
1363
final_parent = tt.final_parent(old_file)
1364
if new_file in divert:
1365
new_name = tt.final_name(old_file)+'.diverted'
1366
tt.adjust_path(new_name, final_parent, new_file)
1367
new_conflicts.add((c_type, 'Diverted to',
1368
new_file, old_file))
1370
new_name = tt.final_name(old_file)+'.moved'
1371
tt.adjust_path(new_name, final_parent, old_file)
1372
new_conflicts.add((c_type, 'Moved existing file to',
1373
old_file, new_file))
1374
return new_conflicts
1377
def new_by_entry(tt, entry, parent_id, tree):
1378
"""Create a new file according to its inventory entry"""
1382
contents = tree.get_file(entry.file_id).readlines()
1383
executable = tree.is_executable(entry.file_id)
1384
return tt.new_file(name, parent_id, contents, entry.file_id,
1386
elif kind in ('directory', 'tree-reference'):
1387
trans_id = tt.new_directory(name, parent_id, entry.file_id)
1388
if kind == 'tree-reference':
1389
tt.set_tree_reference(entry.reference_revision, trans_id)
1391
elif kind == 'symlink':
1392
target = tree.get_symlink_target(entry.file_id)
1393
return tt.new_symlink(name, parent_id, target, entry.file_id)
1395
raise errors.BadFileKindError(name, kind)
1397
def create_by_entry(tt, entry, tree, trans_id, lines=None, mode_id=None):
1398
"""Create new file contents according to an inventory entry."""
1399
if entry.kind == "file":
1401
lines = tree.get_file(entry.file_id).readlines()
1402
tt.create_file(lines, trans_id, mode_id=mode_id)
1403
elif entry.kind == "symlink":
1404
tt.create_symlink(tree.get_symlink_target(entry.file_id), trans_id)
1405
elif entry.kind == "directory":
1406
tt.create_directory(trans_id)
1408
def create_entry_executability(tt, entry, trans_id):
1409
"""Set the executability of a trans_id according to an inventory entry"""
1410
if entry.kind == "file":
1411
tt.set_executability(entry.executable, trans_id)
1414
@deprecated_function(zero_fifteen)
1415
def find_interesting(working_tree, target_tree, filenames):
1416
"""Find the ids corresponding to specified filenames.
1418
Deprecated: Please use tree1.paths2ids(filenames, [tree2]).
1420
working_tree.lock_read()
1422
target_tree.lock_read()
1424
return working_tree.paths2ids(filenames, [target_tree])
1426
target_tree.unlock()
1428
working_tree.unlock()
1431
@deprecated_function(zero_ninety)
1432
def change_entry(tt, file_id, working_tree, target_tree,
1433
trans_id_file_id, backups, trans_id, by_parent):
1434
"""Replace a file_id's contents with those from a target tree."""
1435
if file_id is None and target_tree is None:
1436
# skip the logic altogether in the deprecation test
1438
e_trans_id = trans_id_file_id(file_id)
1439
entry = target_tree.inventory[file_id]
1440
has_contents, contents_mod, meta_mod, = _entry_changes(file_id, entry,
1443
mode_id = e_trans_id
1446
tt.delete_contents(e_trans_id)
1448
parent_trans_id = trans_id_file_id(entry.parent_id)
1449
backup_name = get_backup_name(entry, by_parent,
1450
parent_trans_id, tt)
1451
tt.adjust_path(backup_name, parent_trans_id, e_trans_id)
1452
tt.unversion_file(e_trans_id)
1453
e_trans_id = tt.create_path(entry.name, parent_trans_id)
1454
tt.version_file(file_id, e_trans_id)
1455
trans_id[file_id] = e_trans_id
1456
create_by_entry(tt, entry, target_tree, e_trans_id, mode_id=mode_id)
1457
create_entry_executability(tt, entry, e_trans_id)
1460
tt.set_executability(entry.executable, e_trans_id)
1461
if tt.final_name(e_trans_id) != entry.name:
1464
parent_id = tt.final_parent(e_trans_id)
1465
parent_file_id = tt.final_file_id(parent_id)
1466
if parent_file_id != entry.parent_id:
1471
parent_trans_id = trans_id_file_id(entry.parent_id)
1472
tt.adjust_path(entry.name, parent_trans_id, e_trans_id)
1475
def get_backup_name(entry, by_parent, parent_trans_id, tt):
1476
return _get_backup_name(entry.name, by_parent, parent_trans_id, tt)
1479
def _get_backup_name(name, by_parent, parent_trans_id, tt):
1480
"""Produce a backup-style name that appears to be available"""
1484
yield "%s.~%d~" % (name, counter)
1486
for new_name in name_gen():
1487
if not tt.has_named_child(by_parent, parent_trans_id, new_name):
1491
def _entry_changes(file_id, entry, working_tree):
1492
"""Determine in which ways the inventory entry has changed.
1494
Returns booleans: has_contents, content_mod, meta_mod
1495
has_contents means there are currently contents, but they differ
1496
contents_mod means contents need to be modified
1497
meta_mod means the metadata needs to be modified
1499
cur_entry = working_tree.inventory[file_id]
1501
working_kind = working_tree.kind(file_id)
1504
has_contents = False
1507
if has_contents is True:
1508
if entry.kind != working_kind:
1509
contents_mod, meta_mod = True, False
1511
cur_entry._read_tree_state(working_tree.id2path(file_id),
1513
contents_mod, meta_mod = entry.detect_changes(cur_entry)
1514
cur_entry._forget_tree_state()
1515
return has_contents, contents_mod, meta_mod
1518
def revert(working_tree, target_tree, filenames, backups=False,
1519
pb=DummyProgress(), change_reporter=None):
1520
"""Revert a working tree's contents to those of a target tree."""
1521
target_tree.lock_read()
1522
tt = TreeTransform(working_tree, pb)
1524
pp = ProgressPhase("Revert phase", 3, pb)
1526
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1528
merge_modified = _alter_files(working_tree, target_tree, tt,
1529
child_pb, filenames, backups)
1533
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1535
raw_conflicts = resolve_conflicts(tt, child_pb)
1538
conflicts = cook_conflicts(raw_conflicts, tt)
1540
change_reporter = delta._ChangeReporter(
1541
unversioned_filter=working_tree.is_ignored)
1542
delta.report_changes(tt._iter_changes(), change_reporter)
1543
for conflict in conflicts:
1547
working_tree.set_merge_modified(merge_modified)
1549
target_tree.unlock()
1555
def _alter_files(working_tree, target_tree, tt, pb, specific_files,
1557
merge_modified = working_tree.merge_modified()
1558
change_list = target_tree._iter_changes(working_tree,
1559
specific_files=specific_files, pb=pb)
1560
if target_tree.inventory.root is None:
1566
for id_num, (file_id, path, changed_content, versioned, parent, name,
1567
kind, executable) in enumerate(change_list):
1568
if skip_root and file_id[0] is not None and parent[0] is None:
1570
trans_id = tt.trans_id_file_id(file_id)
1573
keep_content = False
1574
if kind[0] == 'file' and (backups or kind[1] is None):
1575
wt_sha1 = working_tree.get_file_sha1(file_id)
1576
if merge_modified.get(file_id) != wt_sha1:
1577
# acquire the basis tree lazily to prevent the
1578
# expense of accessing it when it's not needed ?
1579
# (Guessing, RBC, 200702)
1580
if basis_tree is None:
1581
basis_tree = working_tree.basis_tree()
1582
basis_tree.lock_read()
1583
if file_id in basis_tree:
1584
if wt_sha1 != basis_tree.get_file_sha1(file_id):
1586
elif kind[1] is None and not versioned[1]:
1588
if kind[0] is not None:
1589
if not keep_content:
1590
tt.delete_contents(trans_id)
1591
elif kind[1] is not None:
1592
parent_trans_id = tt.trans_id_file_id(parent[0])
1593
by_parent = tt.by_parent()
1594
backup_name = _get_backup_name(name[0], by_parent,
1595
parent_trans_id, tt)
1596
tt.adjust_path(backup_name, parent_trans_id, trans_id)
1597
new_trans_id = tt.create_path(name[0], parent_trans_id)
1598
if versioned == (True, True):
1599
tt.unversion_file(trans_id)
1600
tt.version_file(file_id, new_trans_id)
1601
# New contents should have the same unix perms as old
1604
trans_id = new_trans_id
1605
if kind[1] == 'directory':
1606
tt.create_directory(trans_id)
1607
elif kind[1] == 'symlink':
1608
tt.create_symlink(target_tree.get_symlink_target(file_id),
1610
elif kind[1] == 'file':
1611
tt.create_file(target_tree.get_file_lines(file_id),
1613
if basis_tree is None:
1614
basis_tree = working_tree.basis_tree()
1615
basis_tree.lock_read()
1616
new_sha1 = target_tree.get_file_sha1(file_id)
1617
if (file_id in basis_tree and new_sha1 ==
1618
basis_tree.get_file_sha1(file_id)):
1619
if file_id in merge_modified:
1620
del merge_modified[file_id]
1622
merge_modified[file_id] = new_sha1
1624
# preserve the execute bit when backing up
1625
if keep_content and executable[0] == executable[1]:
1626
tt.set_executability(executable[1], trans_id)
1628
assert kind[1] is None
1629
if versioned == (False, True):
1630
tt.version_file(file_id, trans_id)
1631
if versioned == (True, False):
1632
tt.unversion_file(trans_id)
1633
if (name[1] is not None and
1634
(name[0] != name[1] or parent[0] != parent[1])):
1636
name[1], tt.trans_id_file_id(parent[1]), trans_id)
1637
if executable[0] != executable[1] and kind[1] == "file":
1638
tt.set_executability(executable[1], trans_id)
1640
if basis_tree is not None:
1642
return merge_modified
1645
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
1646
"""Make many conflict-resolution attempts, but die if they fail"""
1647
if pass_func is None:
1648
pass_func = conflict_pass
1649
new_conflicts = set()
1652
pb.update('Resolution pass', n+1, 10)
1653
conflicts = tt.find_conflicts()
1654
if len(conflicts) == 0:
1655
return new_conflicts
1656
new_conflicts.update(pass_func(tt, conflicts))
1657
raise MalformedTransform(conflicts=conflicts)
1662
def conflict_pass(tt, conflicts, path_tree=None):
1663
"""Resolve some classes of conflicts.
1665
:param tt: The transform to resolve conflicts in
1666
:param conflicts: The conflicts to resolve
1667
:param path_tree: A Tree to get supplemental paths from
1669
new_conflicts = set()
1670
for c_type, conflict in ((c[0], c) for c in conflicts):
1671
if c_type == 'duplicate id':
1672
tt.unversion_file(conflict[1])
1673
new_conflicts.add((c_type, 'Unversioned existing file',
1674
conflict[1], conflict[2], ))
1675
elif c_type == 'duplicate':
1676
# files that were renamed take precedence
1677
new_name = tt.final_name(conflict[1])+'.moved'
1678
final_parent = tt.final_parent(conflict[1])
1679
if tt.path_changed(conflict[1]):
1680
tt.adjust_path(new_name, final_parent, conflict[2])
1681
new_conflicts.add((c_type, 'Moved existing file to',
1682
conflict[2], conflict[1]))
1684
tt.adjust_path(new_name, final_parent, conflict[1])
1685
new_conflicts.add((c_type, 'Moved existing file to',
1686
conflict[1], conflict[2]))
1687
elif c_type == 'parent loop':
1688
# break the loop by undoing one of the ops that caused the loop
1690
while not tt.path_changed(cur):
1691
cur = tt.final_parent(cur)
1692
new_conflicts.add((c_type, 'Cancelled move', cur,
1693
tt.final_parent(cur),))
1694
tt.adjust_path(tt.final_name(cur), tt.get_tree_parent(cur), cur)
1696
elif c_type == 'missing parent':
1697
trans_id = conflict[1]
1699
tt.cancel_deletion(trans_id)
1700
new_conflicts.add(('deleting parent', 'Not deleting',
1703
tt.create_directory(trans_id)
1704
new_conflicts.add((c_type, 'Created directory', trans_id))
1706
tt.final_name(trans_id)
1708
file_id = tt.final_file_id(trans_id)
1709
entry = path_tree.inventory[file_id]
1710
parent_trans_id = tt.trans_id_file_id(entry.parent_id)
1711
tt.adjust_path(entry.name, parent_trans_id, trans_id)
1712
elif c_type == 'unversioned parent':
1713
tt.version_file(tt.inactive_file_id(conflict[1]), conflict[1])
1714
new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
1715
return new_conflicts
1718
def cook_conflicts(raw_conflicts, tt):
1719
"""Generate a list of cooked conflicts, sorted by file path"""
1720
from bzrlib.conflicts import Conflict
1721
conflict_iter = iter_cook_conflicts(raw_conflicts, tt)
1722
return sorted(conflict_iter, key=Conflict.sort_key)
1725
def iter_cook_conflicts(raw_conflicts, tt):
1726
from bzrlib.conflicts import Conflict
1728
for conflict in raw_conflicts:
1729
c_type = conflict[0]
1730
action = conflict[1]
1731
modified_path = fp.get_path(conflict[2])
1732
modified_id = tt.final_file_id(conflict[2])
1733
if len(conflict) == 3:
1734
yield Conflict.factory(c_type, action=action, path=modified_path,
1735
file_id=modified_id)
1738
conflicting_path = fp.get_path(conflict[3])
1739
conflicting_id = tt.final_file_id(conflict[3])
1740
yield Conflict.factory(c_type, action=action, path=modified_path,
1741
file_id=modified_id,
1742
conflict_path=conflicting_path,
1743
conflict_file_id=conflicting_id)
added
removed
bzrlib/transform.py
