« back to all changes in this revision
Viewing changes to bzrlib/_changeset.py
- browse files at revision 1558
- compare with another revision
- compare with revision 4476.3.35
- download diff
- download tarball
- view history from revision 1558
- Committer: Canonical.com Patch Queue Manager
- Date: 2006-02-21 02:17:34 UTC
- mfrom: (1534.7.182 Transactional Tree Transforms)
- Revision ID: pqm@pqm.ubuntu.com-20060221021734-ccbecdd31223385c
Tree Transform-based merger
- files added:
- bzrlib/tests/test_transform.py
- files removed:
- bzrlib/_changeset.py
- files modified:
- NEWS
added
removed
bzrlib/_changeset.py
1
# Copyright (C) 2004 Aaron Bentley <aaron.bentley@utoronto.ca>
2
#
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.
7
#
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.
12
#
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
16
17
"""Represent and apply a changeset.
18
19
Conflicts in applying a changeset are represented as exceptions.
20
21
This only handles the in-memory objects representing changesets, which are
22
primarily used by the merge code.
23
"""
24
25
import os.path
26
import errno
27
import stat
28
from shutil import rmtree
29
from itertools import izip
30
31
from bzrlib.trace import mutter, warning
32
from bzrlib.osutils import rename, sha_file, pathjoin, mkdtemp
33
import bzrlib
34
from bzrlib.errors import BzrCheckError
35
36
__docformat__ = "restructuredtext"
37
38
39
NULL_ID = "!NULL"
40
41
42
class OldFailedTreeOp(Exception):
43
def __init__(self):
44
Exception.__init__(self, "bzr-tree-change contains files from a"
45
" previous failed merge operation.")
46
47
48
def invert_dict(dict):
49
newdict = {}
50
for (key,value) in dict.iteritems():
51
newdict[value] = key
52
return newdict
53
54
55
class ChangeExecFlag(object):
56
"""This is two-way change, suitable for file modification, creation,
57
deletion"""
58
def __init__(self, old_exec_flag, new_exec_flag):
59
self.old_exec_flag = old_exec_flag
60
self.new_exec_flag = new_exec_flag
61
62
def apply(self, filename, conflict_handler):
63
from_exec_flag = self.old_exec_flag
64
to_exec_flag = self.new_exec_flag
65
try:
66
current_exec_flag = bool(os.stat(filename).st_mode & 0111)
67
except OSError, e:
68
if e.errno == errno.ENOENT:
69
if conflict_handler.missing_for_exec_flag(filename) == "skip":
70
return
71
else:
72
current_exec_flag = from_exec_flag
73
74
if from_exec_flag is not None and current_exec_flag != from_exec_flag:
75
if conflict_handler.wrong_old_exec_flag(filename,
76
from_exec_flag, current_exec_flag) != "continue":
77
return
78
79
if to_exec_flag is not None:
80
current_mode = os.stat(filename).st_mode
81
if to_exec_flag:
82
umask = os.umask(0)
83
os.umask(umask)
84
to_mode = current_mode | (0100 & ~umask)
85
# Enable x-bit for others only if they can read it.
86
if current_mode & 0004:
87
to_mode |= 0001 & ~umask
88
if current_mode & 0040:
89
to_mode |= 0010 & ~umask
90
else:
91
to_mode = current_mode & ~0111
92
try:
93
os.chmod(filename, to_mode)
94
except IOError, e:
95
if e.errno == errno.ENOENT:
96
conflict_handler.missing_for_exec_flag(filename)
97
98
def __eq__(self, other):
99
return (isinstance(other, ChangeExecFlag) and
100
self.old_exec_flag == other.old_exec_flag and
101
self.new_exec_flag == other.new_exec_flag)
102
103
def __ne__(self, other):
104
return not (self == other)
105
106
107
def dir_create(filename, conflict_handler, reverse=False):
108
"""Creates the directory, or deletes it if reverse is true. Intended to be
109
used with ReplaceContents.
110
111
:param filename: The name of the directory to create
112
:type filename: str
113
:param reverse: If true, delete the directory, instead
114
:type reverse: bool
115
"""
116
if not reverse:
117
try:
118
os.mkdir(filename)
119
except OSError, e:
120
if e.errno != errno.EEXIST:
121
raise
122
if conflict_handler.dir_exists(filename) == "continue":
123
os.mkdir(filename)
124
except IOError, e:
125
if e.errno == errno.ENOENT:
126
if conflict_handler.missing_parent(filename)=="continue":
127
file(filename, "wb").write(self.contents)
128
else:
129
try:
130
os.rmdir(filename)
131
except OSError, e:
132
if e.errno != errno.ENOTEMPTY:
133
raise
134
if conflict_handler.rmdir_non_empty(filename) == "skip":
135
return
136
os.rmdir(filename)
137
138
139
class SymlinkCreate(object):
140
"""Creates or deletes a symlink (for use with ReplaceContents)"""
141
def __init__(self, contents):
142
"""Constructor.
143
144
:param contents: The filename of the target the symlink should point to
145
:type contents: str
146
"""
147
self.target = contents
148
149
def __repr__(self):
150
return "SymlinkCreate(%s)" % self.target
151
152
def __call__(self, filename, conflict_handler, reverse=False):
153
"""Creates or destroys the symlink.
154
155
:param filename: The name of the symlink to create
156
:type filename: str
157
"""
158
if reverse:
159
assert(os.readlink(filename) == self.target)
160
os.unlink(filename)
161
else:
162
try:
163
os.symlink(self.target, filename)
164
except OSError, e:
165
if e.errno != errno.EEXIST:
166
raise
167
if conflict_handler.link_name_exists(filename) == "continue":
168
os.symlink(self.target, filename)
169
170
def __eq__(self, other):
171
if not isinstance(other, SymlinkCreate):
172
return False
173
elif self.target != other.target:
174
return False
175
else:
176
return True
177
178
def __ne__(self, other):
179
return not (self == other)
180
181
182
class FileCreate(object):
183
"""Create or delete a file (for use with ReplaceContents)"""
184
def __init__(self, contents):
185
"""Constructor
186
187
:param contents: The contents of the file to write
188
:type contents: str
189
"""
190
self.contents = contents
191
192
def __repr__(self):
193
return "FileCreate(%i b)" % len(self.contents)
194
195
def __eq__(self, other):
196
if not isinstance(other, FileCreate):
197
return False
198
elif self.contents != other.contents:
199
return False
200
else:
201
return True
202
203
def __ne__(self, other):
204
return not (self == other)
205
206
def __call__(self, filename, conflict_handler, reverse=False):
207
"""Create or delete a file
208
209
:param filename: The name of the file to create
210
:type filename: str
211
:param reverse: Delete the file instead of creating it
212
:type reverse: bool
213
"""
214
if not reverse:
215
try:
216
file(filename, "wb").write(self.contents)
217
except IOError, e:
218
if e.errno == errno.ENOENT:
219
if conflict_handler.missing_parent(filename)=="continue":
220
file(filename, "wb").write(self.contents)
221
else:
222
raise
223
224
else:
225
try:
226
if (file(filename, "rb").read() != self.contents):
227
direction = conflict_handler.wrong_old_contents(filename,
228
self.contents)
229
if direction != "continue":
230
return
231
os.unlink(filename)
232
except IOError, e:
233
if e.errno != errno.ENOENT:
234
raise
235
if conflict_handler.missing_for_rm(filename, undo) == "skip":
236
return
237
238
239
class TreeFileCreate(object):
240
"""Create or delete a file (for use with ReplaceContents)"""
241
def __init__(self, tree, file_id):
242
"""Constructor
243
244
:param contents: The contents of the file to write
245
:type contents: str
246
"""
247
self.tree = tree
248
self.file_id = file_id
249
250
def __repr__(self):
251
return "TreeFileCreate(%s)" % self.file_id
252
253
def __eq__(self, other):
254
if not isinstance(other, TreeFileCreate):
255
return False
256
return self.tree.get_file_sha1(self.file_id) == \
257
other.tree.get_file_sha1(other.file_id)
258
259
def __ne__(self, other):
260
return not (self == other)
261
262
def write_file(self, filename):
263
outfile = file(filename, "wb")
264
for line in self.tree.get_file(self.file_id):
265
outfile.write(line)
266
267
def same_text(self, filename):
268
in_file = file(filename, "rb")
269
return sha_file(in_file) == self.tree.get_file_sha1(self.file_id)
270
271
def __call__(self, filename, conflict_handler, reverse=False):
272
"""Create or delete a file
273
274
:param filename: The name of the file to create
275
:type filename: str
276
:param reverse: Delete the file instead of creating it
277
:type reverse: bool
278
"""
279
if not reverse:
280
try:
281
self.write_file(filename)
282
except IOError, e:
283
if e.errno == errno.ENOENT:
284
if conflict_handler.missing_parent(filename)=="continue":
285
self.write_file(filename)
286
else:
287
raise
288
289
else:
290
try:
291
if not self.same_text(filename):
292
direction = conflict_handler.wrong_old_contents(filename,
293
self.tree.get_file(self.file_id).read())
294
if direction != "continue":
295
return
296
os.unlink(filename)
297
except IOError, e:
298
if e.errno != errno.ENOENT:
299
raise
300
if conflict_handler.missing_for_rm(filename, undo) == "skip":
301
return
302
303
304
class ReplaceContents(object):
305
"""A contents-replacement framework. It allows a file/directory/symlink to
306
be created, deleted, or replaced with another file/directory/symlink.
307
Arguments must be callable with (filename, reverse).
308
"""
309
def __init__(self, old_contents, new_contents):
310
"""Constructor.
311
312
:param old_contents: The change to reverse apply (e.g. a deletion), \
313
when going forwards.
314
:type old_contents: `dir_create`, `SymlinkCreate`, `FileCreate`, \
315
NoneType, etc.
316
:param new_contents: The second change to apply (e.g. a creation), \
317
when going forwards.
318
:type new_contents: `dir_create`, `SymlinkCreate`, `FileCreate`, \
319
NoneType, etc.
320
"""
321
self.old_contents=old_contents
322
self.new_contents=new_contents
323
324
def __repr__(self):
325
return "ReplaceContents(%r -> %r)" % (self.old_contents,
326
self.new_contents)
327
328
def __eq__(self, other):
329
if not isinstance(other, ReplaceContents):
330
return False
331
elif self.old_contents != other.old_contents:
332
return False
333
elif self.new_contents != other.new_contents:
334
return False
335
else:
336
return True
337
def __ne__(self, other):
338
return not (self == other)
339
340
def apply(self, filename, conflict_handler):
341
"""Applies the FileReplacement to the specified filename
342
343
:param filename: The name of the file to apply changes to
344
:type filename: str
345
"""
346
undo = self.old_contents
347
perform = self.new_contents
348
mode = None
349
if undo is not None:
350
try:
351
mode = os.lstat(filename).st_mode
352
if stat.S_ISLNK(mode):
353
mode = None
354
except OSError, e:
355
if e.errno != errno.ENOENT:
356
raise
357
if conflict_handler.missing_for_rm(filename, undo) == "skip":
358
return
359
undo(filename, conflict_handler, reverse=True)
360
if perform is not None:
361
perform(filename, conflict_handler)
362
if mode is not None:
363
os.chmod(filename, mode)
364
365
def is_creation(self):
366
return self.new_contents is not None and self.old_contents is None
367
368
def is_deletion(self):
369
return self.old_contents is not None and self.new_contents is None
370
371
372
class Diff3Merge(object):
373
history_based = False
374
def __init__(self, file_id, base, other):
375
self.file_id = file_id
376
self.base = base
377
self.other = other
378
379
def is_creation(self):
380
return False
381
382
def is_deletion(self):
383
return False
384
385
def __eq__(self, other):
386
if not isinstance(other, Diff3Merge):
387
return False
388
return (self.base == other.base and
389
self.other == other.other and self.file_id == other.file_id)
390
391
def __ne__(self, other):
392
return not (self == other)
393
394
def dump_file(self, temp_dir, name, tree):
395
out_path = pathjoin(temp_dir, name)
396
out_file = file(out_path, "wb")
397
in_file = tree.get_file(self.file_id)
398
for line in in_file:
399
out_file.write(line)
400
return out_path
401
402
def apply(self, filename, conflict_handler):
403
import bzrlib.patch
404
temp_dir = mkdtemp(prefix="bzr-", dir=os.path.dirname(filename))
405
try:
406
new_file = os.path.join(temp_dir, filename)
407
base_file = self.dump_file(temp_dir, "base", self.base)
408
other_file = self.dump_file(temp_dir, "other", self.other)
409
base = base_file
410
other = other_file
411
status = bzrlib.patch.diff3(new_file, filename, base, other)
412
if status == 0:
413
os.chmod(new_file, os.stat(filename).st_mode)
414
rename(new_file, filename)
415
return
416
else:
417
assert(status == 1)
418
def get_lines(filename):
419
my_file = file(filename, "rb")
420
lines = my_file.readlines()
421
my_file.close()
422
return lines
423
base_lines = get_lines(base)
424
other_lines = get_lines(other)
425
conflict_handler.merge_conflict(new_file, filename, base_lines,
426
other_lines)
427
finally:
428
rmtree(temp_dir)
429
430
431
def CreateDir():
432
"""Convenience function to create a directory.
433
434
:return: A ReplaceContents that will create a directory
435
:rtype: `ReplaceContents`
436
"""
437
return ReplaceContents(None, dir_create)
438
439
440
def DeleteDir():
441
"""Convenience function to delete a directory.
442
443
:return: A ReplaceContents that will delete a directory
444
:rtype: `ReplaceContents`
445
"""
446
return ReplaceContents(dir_create, None)
447
448
449
def CreateFile(contents):
450
"""Convenience fucntion to create a file.
451
452
:param contents: The contents of the file to create
453
:type contents: str
454
:return: A ReplaceContents that will create a file
455
:rtype: `ReplaceContents`
456
"""
457
return ReplaceContents(None, FileCreate(contents))
458
459
460
def DeleteFile(contents):
461
"""Convenience fucntion to delete a file.
462
463
:param contents: The contents of the file to delete
464
:type contents: str
465
:return: A ReplaceContents that will delete a file
466
:rtype: `ReplaceContents`
467
"""
468
return ReplaceContents(FileCreate(contents), None)
469
470
471
def ReplaceFileContents(old_tree, new_tree, file_id):
472
"""Convenience fucntion to replace the contents of a file.
473
474
:param old_contents: The contents of the file to replace
475
:type old_contents: str
476
:param new_contents: The contents to replace the file with
477
:type new_contents: str
478
:return: A ReplaceContents that will replace the contents of a file a file
479
:rtype: `ReplaceContents`
480
"""
481
return ReplaceContents(TreeFileCreate(old_tree, file_id),
482
TreeFileCreate(new_tree, file_id))
483
484
485
def CreateSymlink(target):
486
"""Convenience fucntion to create a symlink.
487
488
:param target: The path the link should point to
489
:type target: str
490
:return: A ReplaceContents that will delete a file
491
:rtype: `ReplaceContents`
492
"""
493
return ReplaceContents(None, SymlinkCreate(target))
494
495
496
def DeleteSymlink(target):
497
"""Convenience fucntion to delete a symlink.
498
499
:param target: The path the link should point to
500
:type target: str
501
:return: A ReplaceContents that will delete a file
502
:rtype: `ReplaceContents`
503
"""
504
return ReplaceContents(SymlinkCreate(target), None)
505
506
507
def ChangeTarget(old_target, new_target):
508
"""Convenience fucntion to change the target of a symlink.
509
510
:param old_target: The current link target
511
:type old_target: str
512
:param new_target: The new link target to use
513
:type new_target: str
514
:return: A ReplaceContents that will delete a file
515
:rtype: `ReplaceContents`
516
"""
517
return ReplaceContents(SymlinkCreate(old_target), SymlinkCreate(new_target))
518
519
520
class InvalidEntry(Exception):
521
"""Raise when a ChangesetEntry is invalid in some way"""
522
def __init__(self, entry, problem):
523
"""Constructor.
524
525
:param entry: The invalid ChangesetEntry
526
:type entry: `ChangesetEntry`
527
:param problem: The problem with the entry
528
:type problem: str
529
"""
530
msg = "Changeset entry for %s (%s) is invalid.\n%s" % (entry.id,
531
entry.path,
532
problem)
533
Exception.__init__(self, msg)
534
self.entry = entry
535
536
537
class SourceRootHasName(InvalidEntry):
538
"""This changeset entry has a name other than "", but its parent is !NULL"""
539
def __init__(self, entry, name):
540
"""Constructor.
541
542
:param entry: The invalid ChangesetEntry
543
:type entry: `ChangesetEntry`
544
:param name: The name of the entry
545
:type name: str
546
"""
547
msg = 'Child of !NULL is named "%s", not "./.".' % name
548
InvalidEntry.__init__(self, entry, msg)
549
550
551
class NullIDAssigned(InvalidEntry):
552
"""The id !NULL was assigned to a real entry"""
553
def __init__(self, entry):
554
"""Constructor.
555
556
:param entry: The invalid ChangesetEntry
557
:type entry: `ChangesetEntry`
558
"""
559
msg = '"!NULL" id assigned to a file "%s".' % entry.path
560
InvalidEntry.__init__(self, entry, msg)
561
562
563
class ParentIDIsSelf(InvalidEntry):
564
"""An entry is marked as its own parent"""
565
def __init__(self, entry):
566
"""Constructor.
567
568
:param entry: The invalid ChangesetEntry
569
:type entry: `ChangesetEntry`
570
"""
571
msg = 'file %s has "%s" id for both self id and parent id.' % \
572
(entry.path, entry.id)
573
InvalidEntry.__init__(self, entry, msg)
574
575
576
class ChangesetEntry(object):
577
"""An entry the changeset"""
578
def __init__(self, id, parent, path):
579
"""Constructor. Sets parent and name assuming it was not
580
renamed/created/deleted.
581
:param id: The id associated with the entry
582
:param parent: The id of the parent of this entry (or !NULL if no
583
parent)
584
:param path: The file path relative to the tree root of this entry
585
"""
586
self.id = id
587
self.path = path
588
self.new_path = path
589
self.parent = parent
590
self.new_parent = parent
591
self.contents_change = None
592
self.metadata_change = None
593
if parent == NULL_ID and path !='./.':
594
raise SourceRootHasName(self, path)
595
if self.id == NULL_ID:
596
raise NullIDAssigned(self)
597
if self.id == self.parent:
598
raise ParentIDIsSelf(self)
599
600
def __repr__(self):
601
return "ChangesetEntry(%s)" % self.id
602
603
__str__ = __repr__
604
605
def __get_dir(self):
606
if self.path is None:
607
return None
608
return os.path.dirname(self.path)
609
610
def __set_dir(self, dir):
611
self.path = pathjoin(dir, os.path.basename(self.path))
612
613
dir = property(__get_dir, __set_dir)
614
615
def __get_name(self):
616
if self.path is None:
617
return None
618
return os.path.basename(self.path)
619
620
def __set_name(self, name):
621
self.path = pathjoin(os.path.dirname(self.path), name)
622
623
name = property(__get_name, __set_name)
624
625
def __get_new_dir(self):
626
if self.new_path is None:
627
return None
628
return os.path.dirname(self.new_path)
629
630
def __set_new_dir(self, dir):
631
self.new_path = pathjoin(dir, os.path.basename(self.new_path))
632
633
new_dir = property(__get_new_dir, __set_new_dir)
634
635
def __get_new_name(self):
636
if self.new_path is None:
637
return None
638
return os.path.basename(self.new_path)
639
640
def __set_new_name(self, name):
641
self.new_path = pathjoin(os.path.dirname(self.new_path), name)
642
643
new_name = property(__get_new_name, __set_new_name)
644
645
def needs_rename(self):
646
"""Determines whether the entry requires renaming.
647
648
:rtype: bool
649
"""
650
return (self.parent != self.new_parent or self.name != self.new_name)
651
652
def is_deletion(self, reverse=False):
653
"""Return true if applying the entry would delete a file/directory.
654
655
:param reverse: if true, the changeset is being applied in reverse
656
:rtype: bool
657
"""
658
return self.is_creation(not reverse)
659
660
def is_creation(self, reverse=False):
661
"""Return true if applying the entry would create a file/directory.
662
663
:param reverse: if true, the changeset is being applied in reverse
664
:rtype: bool
665
"""
666
if self.contents_change is None:
667
return False
668
if reverse:
669
return self.contents_change.is_deletion()
670
else:
671
return self.contents_change.is_creation()
672
673
def is_creation_or_deletion(self):
674
"""Return true if applying the entry would create or delete a
675
file/directory.
676
677
:rtype: bool
678
"""
679
return self.is_creation() or self.is_deletion()
680
681
def get_cset_path(self, mod=False):
682
"""Determine the path of the entry according to the changeset.
683
684
:param changeset: The changeset to derive the path from
685
:type changeset: `Changeset`
686
:param mod: If true, generate the MOD path. Otherwise, generate the \
687
ORIG path.
688
:return: the path of the entry, or None if it did not exist in the \
689
requested tree.
690
:rtype: str or NoneType
691
"""
692
if mod:
693
if self.new_parent == NULL_ID:
694
return "./."
695
elif self.new_parent is None:
696
return None
697
return self.new_path
698
else:
699
if self.parent == NULL_ID:
700
return "./."
701
elif self.parent is None:
702
return None
703
return self.path
704
705
def summarize_name(self):
706
"""Produce a one-line summary of the filename. Indicates renames as
707
old => new, indicates creation as None => new, indicates deletion as
708
old => None.
709
710
:rtype: str
711
"""
712
orig_path = self.get_cset_path(False)
713
mod_path = self.get_cset_path(True)
714
if orig_path and orig_path.startswith('./'):
715
orig_path = orig_path[2:]
716
if mod_path and mod_path.startswith('./'):
717
mod_path = mod_path[2:]
718
if orig_path == mod_path:
719
return orig_path
720
else:
721
return "%s => %s" % (orig_path, mod_path)
722
723
def get_new_path(self, id_map, changeset):
724
"""Determine the full pathname to rename to
725
726
:param id_map: The map of ids to filenames for the tree
727
:type id_map: Dictionary
728
:param changeset: The changeset to get data from
729
:type changeset: `Changeset`
730
:rtype: str
731
"""
732
mutter("Finding new path for %s", self.summarize_name())
733
parent = self.new_parent
734
to_dir = self.new_dir
735
from_dir = self.dir
736
to_name = self.new_name
737
from_name = self.name
738
739
if to_name is None:
740
return None
741
742
if parent == NULL_ID or parent is None:
743
if to_name != u'.':
744
raise SourceRootHasName(self, to_name)
745
else:
746
return u'.'
747
parent_entry = changeset.entries.get(parent)
748
if parent_entry is None:
749
dir = os.path.dirname(id_map[self.id])
750
else:
751
mutter("path, new_path: %r %r", self.path, self.new_path)
752
dir = parent_entry.get_new_path(id_map, changeset)
753
if from_name == to_name:
754
name = os.path.basename(id_map[self.id])
755
else:
756
name = to_name
757
assert(from_name is None or from_name == os.path.basename(id_map[self.id]))
758
return pathjoin(dir, name)
759
760
def is_boring(self):
761
"""Determines whether the entry does nothing
762
763
:return: True if the entry does no renames or content changes
764
:rtype: bool
765
"""
766
if self.contents_change is not None:
767
return False
768
elif self.metadata_change is not None:
769
return False
770
elif self.parent != self.new_parent:
771
return False
772
elif self.name != self.new_name:
773
return False
774
else:
775
return True
776
777
def apply(self, filename, conflict_handler):
778
"""Applies the file content and/or metadata changes.
779
780
:param filename: the filename of the entry
781
:type filename: str
782
"""
783
if self.is_deletion() and self.metadata_change is not None:
784
self.metadata_change.apply(filename, conflict_handler)
785
if self.contents_change is not None:
786
self.contents_change.apply(filename, conflict_handler)
787
if not self.is_deletion() and self.metadata_change is not None:
788
self.metadata_change.apply(filename, conflict_handler)
789
790
791
class IDPresent(Exception):
792
def __init__(self, id):
793
msg = "Cannot add entry because that id has already been used:\n%s" %\
794
id
795
Exception.__init__(self, msg)
796
self.id = id
797
798
799
class Changeset(object):
800
"""A set of changes to apply"""
801
def __init__(self):
802
self.entries = {}
803
804
def add_entry(self, entry):
805
"""Add an entry to the list of entries"""
806
if self.entries.has_key(entry.id):
807
raise IDPresent(entry.id)
808
self.entries[entry.id] = entry
809
810
811
def get_rename_entries(changeset, inventory):
812
"""Return a list of entries that will be renamed. Entries are sorted from
813
longest to shortest source path and from shortest to longest target path.
814
815
:param changeset: The changeset to look in
816
:type changeset: `Changeset`
817
:param inventory: The source of current tree paths for the given ids
818
:type inventory: Dictionary
819
:return: source entries and target entries as a tuple
820
:rtype: (List, List)
821
"""
822
source_entries = [x for x in changeset.entries.itervalues()
823
if x.needs_rename() or x.is_creation_or_deletion()]
824
# these are done from longest path to shortest, to avoid deleting a
825
# parent before its children are deleted/renamed
826
def longest_to_shortest(entry):
827
path = inventory.get(entry.id)
828
if path is None:
829
return 0
830
else:
831
return len(path)
832
source_entries.sort(None, longest_to_shortest, True)
833
834
target_entries = source_entries[:]
835
# These are done from shortest to longest path, to avoid creating a
836
# child before its parent has been created/renamed
837
def shortest_to_longest(entry):
838
path = entry.get_new_path(inventory, changeset)
839
if path is None:
840
return 0
841
else:
842
return len(path)
843
target_entries.sort(None, shortest_to_longest)
844
return (source_entries, target_entries)
845
846
847
def rename_to_temp_delete(source_entries, inventory, dir, temp_dir,
848
conflict_handler):
849
"""Delete and rename entries as appropriate. Entries are renamed to temp
850
names. A map of id -> temp name (or None, for deletions) is returned.
851
852
:param source_entries: The entries to rename and delete
853
:type source_entries: List of `ChangesetEntry`
854
:param inventory: The map of id -> filename in the current tree
855
:type inventory: Dictionary
856
:param dir: The directory to apply changes to
857
:type dir: str
858
:return: a mapping of id to temporary name
859
:rtype: Dictionary
860
"""
861
temp_name = {}
862
for i in range(len(source_entries)):
863
entry = source_entries[i]
864
if entry.is_deletion():
865
path = pathjoin(dir, inventory[entry.id])
866
entry.apply(path, conflict_handler)
867
temp_name[entry.id] = None
868
869
elif entry.needs_rename():
870
if entry.is_creation():
871
continue
872
to_name = pathjoin(temp_dir, str(i))
873
src_path = inventory.get(entry.id)
874
if src_path is not None:
875
src_path = pathjoin(dir, src_path)
876
try:
877
rename(src_path, to_name)
878
temp_name[entry.id] = to_name
879
except OSError, e:
880
if e.errno != errno.ENOENT:
881
raise
882
if conflict_handler.missing_for_rename(src_path, to_name) \
883
== "skip":
884
continue
885
886
return temp_name
887
888
889
def rename_to_new_create(changed_inventory, target_entries, inventory,
890
changeset, dir, conflict_handler):
891
"""Rename entries with temp names to their final names, create new files.
892
893
:param changed_inventory: A mapping of id to temporary name
894
:type changed_inventory: Dictionary
895
:param target_entries: The entries to apply changes to
896
:type target_entries: List of `ChangesetEntry`
897
:param changeset: The changeset to apply
898
:type changeset: `Changeset`
899
:param dir: The directory to apply changes to
900
:type dir: str
901
"""
902
for entry in target_entries:
903
new_tree_path = entry.get_new_path(inventory, changeset)
904
if new_tree_path is None:
905
continue
906
new_path = pathjoin(dir, new_tree_path)
907
old_path = changed_inventory.get(entry.id)
908
if bzrlib.osutils.lexists(new_path):
909
if conflict_handler.target_exists(entry, new_path, old_path) == \
910
"skip":
911
continue
912
if entry.is_creation():
913
entry.apply(new_path, conflict_handler)
914
changed_inventory[entry.id] = new_tree_path
915
elif entry.needs_rename():
916
if entry.is_deletion():
917
continue
918
if old_path is None:
919
continue
920
try:
921
mutter('rename %s to final name %s', old_path, new_path)
922
rename(old_path, new_path)
923
changed_inventory[entry.id] = new_tree_path
924
except OSError, e:
925
raise BzrCheckError('failed to rename %s to %s for changeset entry %s: %s'
926
% (old_path, new_path, entry, e))
927
928
929
class TargetExists(Exception):
930
def __init__(self, entry, target):
931
msg = "The path %s already exists" % target
932
Exception.__init__(self, msg)
933
self.entry = entry
934
self.target = target
935
936
937
class RenameConflict(Exception):
938
def __init__(self, id, this_name, base_name, other_name):
939
msg = """Trees all have different names for a file
940
this: %s
941
base: %s
942
other: %s
943
id: %s""" % (this_name, base_name, other_name, id)
944
Exception.__init__(self, msg)
945
self.this_name = this_name
946
self.base_name = base_name
947
self_other_name = other_name
948
949
950
class MoveConflict(Exception):
951
def __init__(self, id, this_parent, base_parent, other_parent):
952
msg = """The file is in different directories in every tree
953
this: %s
954
base: %s
955
other: %s
956
id: %s""" % (this_parent, base_parent, other_parent, id)
957
Exception.__init__(self, msg)
958
self.this_parent = this_parent
959
self.base_parent = base_parent
960
self_other_parent = other_parent
961
962
963
class MergeConflict(Exception):
964
def __init__(self, this_path):
965
Exception.__init__(self, "Conflict applying changes to %s" % this_path)
966
self.this_path = this_path
967
968
969
class WrongOldContents(Exception):
970
def __init__(self, filename):
971
msg = "Contents mismatch deleting %s" % filename
972
self.filename = filename
973
Exception.__init__(self, msg)
974
975
976
class WrongOldExecFlag(Exception):
977
def __init__(self, filename, old_exec_flag, new_exec_flag):
978
msg = "Executable flag missmatch on %s:\n" \
979
"Expected %s, got %s." % (filename, old_exec_flag, new_exec_flag)
980
self.filename = filename
981
Exception.__init__(self, msg)
982
983
984
class RemoveContentsConflict(Exception):
985
def __init__(self, filename):
986
msg = "Conflict deleting %s, which has different contents in BASE"\
987
" and THIS" % filename
988
self.filename = filename
989
Exception.__init__(self, msg)
990
991
992
class DeletingNonEmptyDirectory(Exception):
993
def __init__(self, filename):
994
msg = "Trying to remove dir %s while it still had files" % filename
995
self.filename = filename
996
Exception.__init__(self, msg)
997
998
999
class PatchTargetMissing(Exception):
1000
def __init__(self, filename):
1001
msg = "Attempt to patch %s, which does not exist" % filename
1002
Exception.__init__(self, msg)
1003
self.filename = filename
1004
1005
1006
class MissingForSetExec(Exception):
1007
def __init__(self, filename):
1008
msg = "Attempt to change permissions on %s, which does not exist" %\
1009
filename
1010
Exception.__init__(self, msg)
1011
self.filename = filename
1012
1013
1014
class MissingForRm(Exception):
1015
def __init__(self, filename):
1016
msg = "Attempt to remove missing path %s" % filename
1017
Exception.__init__(self, msg)
1018
self.filename = filename
1019
1020
1021
class MissingForRename(Exception):
1022
def __init__(self, filename, to_path):
1023
msg = "Attempt to move missing path %s to %s" % (filename, to_path)
1024
Exception.__init__(self, msg)
1025
self.filename = filename
1026
1027
1028
class NewContentsConflict(Exception):
1029
def __init__(self, filename):
1030
msg = "Conflicting contents for new file %s" % (filename)
1031
Exception.__init__(self, msg)
1032
1033
1034
class WeaveMergeConflict(Exception):
1035
def __init__(self, filename):
1036
msg = "Conflicting contents for file %s" % (filename)
1037
Exception.__init__(self, msg)
1038
1039
1040
class ThreewayContentsConflict(Exception):
1041
def __init__(self, filename):
1042
msg = "Conflicting contents for file %s" % (filename)
1043
Exception.__init__(self, msg)
1044
1045
1046
class MissingForMerge(Exception):
1047
def __init__(self, filename):
1048
msg = "The file %s was modified, but does not exist in this tree"\
1049
% (filename)
1050
Exception.__init__(self, msg)
1051
1052
1053
class ExceptionConflictHandler(object):
1054
"""Default handler for merge exceptions.
1055
1056
This throws an error on any kind of conflict. Conflict handlers can
1057
descend from this class if they have a better way to handle some or
1058
all types of conflict.
1059
"""
1060
def missing_parent(self, pathname):
1061
parent = os.path.dirname(pathname)
1062
raise Exception("Parent directory missing for %s" % pathname)
1063
1064
def dir_exists(self, pathname):
1065
raise Exception("Directory already exists for %s" % pathname)
1066
1067
def failed_hunks(self, pathname):
1068
raise Exception("Failed to apply some hunks for %s" % pathname)
1069
1070
def target_exists(self, entry, target, old_path):
1071
raise TargetExists(entry, target)
1072
1073
def rename_conflict(self, id, this_name, base_name, other_name):
1074
raise RenameConflict(id, this_name, base_name, other_name)
1075
1076
def move_conflict(self, id, this_dir, base_dir, other_dir):
1077
raise MoveConflict(id, this_dir, base_dir, other_dir)
1078
1079
def merge_conflict(self, new_file, this_path, base_lines, other_lines):
1080
os.unlink(new_file)
1081
raise MergeConflict(this_path)
1082
1083
def wrong_old_contents(self, filename, expected_contents):
1084
raise WrongOldContents(filename)
1085
1086
def rem_contents_conflict(self, filename, this_contents, base_contents):
1087
raise RemoveContentsConflict(filename)
1088
1089
def wrong_old_exec_flag(self, filename, old_exec_flag, new_exec_flag):
1090
raise WrongOldExecFlag(filename, old_exec_flag, new_exec_flag)
1091
1092
def rmdir_non_empty(self, filename):
1093
raise DeletingNonEmptyDirectory(filename)
1094
1095
def link_name_exists(self, filename):
1096
raise TargetExists(filename)
1097
1098
def patch_target_missing(self, filename, contents):
1099
raise PatchTargetMissing(filename)
1100
1101
def missing_for_exec_flag(self, filename):
1102
raise MissingForExecFlag(filename)
1103
1104
def missing_for_rm(self, filename, change):
1105
raise MissingForRm(filename)
1106
1107
def missing_for_rename(self, filename, to_path):
1108
raise MissingForRename(filename, to_path)
1109
1110
def missing_for_merge(self, file_id, other_path):
1111
raise MissingForMerge(other_path)
1112
1113
def new_contents_conflict(self, filename, other_contents):
1114
raise NewContentsConflict(filename)
1115
1116
def weave_merge_conflict(self, filename, weave, other_i, out_file):
1117
raise WeaveMergeConflict(filename)
1118
1119
def threeway_contents_conflict(self, filename, this_contents,
1120
base_contents, other_contents):
1121
raise ThreewayContentsConflict(filename)
1122
1123
def finalize(self):
1124
pass
1125
1126
1127
def apply_changeset(changeset, inventory, dir, conflict_handler=None):
1128
"""Apply a changeset to a directory.
1129
1130
:param changeset: The changes to perform
1131
:type changeset: `Changeset`
1132
:param inventory: The mapping of id to filename for the directory
1133
:type inventory: Dictionary
1134
:param dir: The path of the directory to apply the changes to
1135
:type dir: str
1136
:return: The mapping of the changed entries
1137
:rtype: Dictionary
1138
"""
1139
if conflict_handler is None:
1140
conflict_handler = ExceptionConflictHandler()
1141
temp_dir = pathjoin(dir, "bzr-tree-change")
1142
try:
1143
os.mkdir(temp_dir)
1144
except OSError, e:
1145
if e.errno == errno.EEXIST:
1146
try:
1147
os.rmdir(temp_dir)
1148
except OSError, e:
1149
if e.errno == errno.ENOTEMPTY:
1150
raise OldFailedTreeOp()
1151
os.mkdir(temp_dir)
1152
else:
1153
raise
1154
1155
#apply changes that don't affect filenames
1156
for entry in changeset.entries.itervalues():
1157
if not entry.is_creation_or_deletion() and not entry.is_boring():
1158
if entry.id not in inventory:
1159
warning("entry {%s} no longer present, can't be updated",
1160
entry.id)
1161
continue
1162
path = pathjoin(dir, inventory[entry.id])
1163
entry.apply(path, conflict_handler)
1164
1165
# Apply renames in stages, to minimize conflicts:
1166
# Only files whose name or parent change are interesting, because their
1167
# target name may exist in the source tree. If a directory's name changes,
1168
# that doesn't make its children interesting.
1169
(source_entries, target_entries) = get_rename_entries(changeset, inventory)
1170
1171
changed_inventory = rename_to_temp_delete(source_entries, inventory, dir,
1172
temp_dir, conflict_handler)
1173
1174
rename_to_new_create(changed_inventory, target_entries, inventory,
1175
changeset, dir, conflict_handler)
1176
os.rmdir(temp_dir)
1177
return changed_inventory
1178
1179
1180
def print_changeset(cset):
1181
"""Print all non-boring changeset entries
1182
1183
:param cset: The changeset to print
1184
:type cset: `Changeset`
1185
"""
1186
for entry in cset.entries.itervalues():
1187
if entry.is_boring():
1188
continue
1189
print entry.id
1190
print entry.summarize_name(cset)
1191
1192
1193
class UnsupportedFiletype(Exception):
1194
def __init__(self, kind, full_path):
1195
msg = "The file \"%s\" is a %s, which is not a supported filetype." \
1196
% (full_path, kind)
1197
Exception.__init__(self, msg)
1198
self.full_path = full_path
1199
self.kind = kind
1200
1201
1202
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1203
return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1204
1205
1206
class ChangesetGenerator(object):
1207
def __init__(self, tree_a, tree_b, interesting_ids=None):
1208
object.__init__(self)
1209
self.tree_a = tree_a
1210
self.tree_b = tree_b
1211
self._interesting_ids = interesting_ids
1212
1213
def iter_both_tree_ids(self):
1214
for file_id in self.tree_a:
1215
yield file_id
1216
for file_id in self.tree_b:
1217
if file_id not in self.tree_a:
1218
yield file_id
1219
1220
def __call__(self):
1221
cset = Changeset()
1222
for file_id in self.iter_both_tree_ids():
1223
cs_entry = self.make_entry(file_id)
1224
if cs_entry is not None and not cs_entry.is_boring():
1225
cset.add_entry(cs_entry)
1226
1227
for entry in list(cset.entries.itervalues()):
1228
if entry.parent != entry.new_parent:
1229
if not cset.entries.has_key(entry.parent) and\
1230
entry.parent != NULL_ID and entry.parent is not None:
1231
parent_entry = self.make_boring_entry(entry.parent)
1232
cset.add_entry(parent_entry)
1233
if not cset.entries.has_key(entry.new_parent) and\
1234
entry.new_parent != NULL_ID and \
1235
entry.new_parent is not None:
1236
parent_entry = self.make_boring_entry(entry.new_parent)
1237
cset.add_entry(parent_entry)
1238
return cset
1239
1240
def iter_inventory(self, tree):
1241
for file_id in tree:
1242
yield self.get_entry(file_id, tree)
1243
1244
def get_entry(self, file_id, tree):
1245
if not tree.has_or_had_id(file_id):
1246
return None
1247
return tree.inventory[file_id]
1248
1249
def get_entry_parent(self, entry):
1250
if entry is None:
1251
return None
1252
return entry.parent_id
1253
1254
def get_path(self, file_id, tree):
1255
if not tree.has_or_had_id(file_id):
1256
return None
1257
path = tree.id2path(file_id)
1258
if path == '':
1259
return './.'
1260
else:
1261
return path
1262
1263
def make_basic_entry(self, file_id, only_interesting):
1264
entry_a = self.get_entry(file_id, self.tree_a)
1265
entry_b = self.get_entry(file_id, self.tree_b)
1266
if only_interesting and not self.is_interesting(entry_a, entry_b):
1267
return None
1268
parent = self.get_entry_parent(entry_a)
1269
path = self.get_path(file_id, self.tree_a)
1270
cs_entry = ChangesetEntry(file_id, parent, path)
1271
new_parent = self.get_entry_parent(entry_b)
1272
1273
new_path = self.get_path(file_id, self.tree_b)
1274
1275
cs_entry.new_path = new_path
1276
cs_entry.new_parent = new_parent
1277
return cs_entry
1278
1279
def is_interesting(self, entry_a, entry_b):
1280
if self._interesting_ids is None:
1281
return True
1282
if entry_a is not None:
1283
file_id = entry_a.file_id
1284
elif entry_b is not None:
1285
file_id = entry_b.file_id
1286
else:
1287
return False
1288
return file_id in self._interesting_ids
1289
1290
def make_boring_entry(self, id):
1291
cs_entry = self.make_basic_entry(id, only_interesting=False)
1292
if cs_entry.is_creation_or_deletion():
1293
return self.make_entry(id, only_interesting=False)
1294
else:
1295
return cs_entry
1296
1297
def make_entry(self, id, only_interesting=True):
1298
cs_entry = self.make_basic_entry(id, only_interesting)
1299
1300
if cs_entry is None:
1301
return None
1302
1303
cs_entry.metadata_change = self.make_exec_flag_change(id)
1304
1305
if id in self.tree_a and id in self.tree_b:
1306
a_sha1 = self.tree_a.get_file_sha1(id)
1307
b_sha1 = self.tree_b.get_file_sha1(id)
1308
if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1309
return cs_entry
1310
1311
cs_entry.contents_change = self.make_contents_change(id)
1312
return cs_entry
1313
1314
def make_exec_flag_change(self, file_id):
1315
exec_flag_a = exec_flag_b = None
1316
if file_id in self.tree_a and self.tree_a.kind(file_id) == "file":
1317
exec_flag_a = self.tree_a.is_executable(file_id)
1318
1319
if file_id in self.tree_b and self.tree_b.kind(file_id) == "file":
1320
exec_flag_b = self.tree_b.is_executable(file_id)
1321
1322
if exec_flag_a == exec_flag_b:
1323
return None
1324
return ChangeExecFlag(exec_flag_a, exec_flag_b)
1325
1326
def make_contents_change(self, file_id):
1327
a_contents = get_contents(self.tree_a, file_id)
1328
b_contents = get_contents(self.tree_b, file_id)
1329
if a_contents == b_contents:
1330
return None
1331
return ReplaceContents(a_contents, b_contents)
1332
1333
1334
def get_contents(tree, file_id):
1335
"""Return the appropriate contents to create a copy of file_id from tree"""
1336
if file_id not in tree:
1337
return None
1338
kind = tree.kind(file_id)
1339
if kind == "file":
1340
return TreeFileCreate(tree, file_id)
1341
elif kind in ("directory", "root_directory"):
1342
return dir_create
1343
elif kind == "symlink":
1344
return SymlinkCreate(tree.get_symlink_target(file_id))
1345
else:
1346
raise UnsupportedFiletype(kind, tree.id2path(file_id))
1347
1348
1349
def full_path(entry, tree):
1350
return pathjoin(tree.basedir, entry.path)
1351
1352
1353
def new_delete_entry(entry, tree, inventory, delete):
1354
if entry.path == "":
1355
parent = NULL_ID
1356
else:
1357
parent = inventory[dirname(entry.path)].id
1358
cs_entry = ChangesetEntry(parent, entry.path)
1359
if delete:
1360
cs_entry.new_path = None
1361
cs_entry.new_parent = None
1362
else:
1363
cs_entry.path = None
1364
cs_entry.parent = None
1365
full_path = full_path(entry, tree)
1366
status = os.lstat(full_path)
1367
if stat.S_ISDIR(file_stat.st_mode):
1368
action = dir_create
1369
1370
1371
# XXX: Can't we unify this with the regular inventory object
1372
class Inventory(object):
1373
def __init__(self, inventory):
1374
self.inventory = inventory
1375
self.rinventory = None
1376
1377
def get_rinventory(self):
1378
if self.rinventory is None:
1379
self.rinventory = invert_dict(self.inventory)
1380
return self.rinventory
1381
1382
def get_path(self, id):
1383
return self.inventory.get(id)
1384
1385
def get_name(self, id):
1386
path = self.get_path(id)
1387
if path is None:
1388
return None
1389
else:
1390
return os.path.basename(path)
1391
1392
def get_dir(self, id):
1393
path = self.get_path(id)
1394
if path == "":
1395
return None
1396
if path is None:
1397
return None
1398
return os.path.dirname(path)
1399
1400
def get_parent(self, id):
1401
if self.get_path(id) is None:
1402
return None
1403
directory = self.get_dir(id)
1404
if directory == '.':
1405
directory = u'./.'
1406
if directory is None:
1407
return NULL_ID
1408
return self.get_rinventory().get(directory)
1409
1410
Loggerhead is a web-based interface for Breezy
Version: 2.0.1