« back to all changes in this revision
Viewing changes to bzrlib/changeset.py
- browse files at revision 558
- compare with another revision
- download diff
- download tarball
- view history from revision 558
- Committer: Martin Pool
- Date: 2005-05-26 02:13:57 UTC
- Revision ID: mbp@sourcefrog.net-20050526021357-9a56decdca0c174f
- All top-level classes inherit from object
(Python new-style classes)
(Python new-style classes)
- files added:
- bzrlib/statcache.py
- files removed:
- HACKING
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- tools
- files renamed:
- contrib/bash/bzr.simple => contrib/bash/bzr
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/util/urlgrabber/ => urlgrabber/
- files modified:
- .bzrignore
added
removed
bzrlib/changeset.py
17
17
import errno
18
18
import patch
19
19
import stat
20
from bzrlib.trace import mutter
21
22
# XXX: mbp: I'm not totally convinced that we should handle conflicts
23
# as part of changeset application, rather than only in the merge
24
# operation.
25
26
"""Represent and apply a changeset
27
28
Conflicts in applying a changeset are represented as exceptions.
29
"""
30
20
"""
21
Represent and apply a changeset
22
"""
31
23
__docformat__ = "restructuredtext"
32
24
33
25
NULL_ID = "!NULL"
34
26
35
class OldFailedTreeOp(Exception):
36
def __init__(self):
37
Exception.__init__(self, "bzr-tree-change contains files from a"
38
" previous failed merge operation.")
27
39
28
def invert_dict(dict):
40
29
newdict = {}
41
30
for (key,value) in dict.iteritems():
43
32
return newdict
44
33
45
34
46
35
class PatchApply(object):
36
"""Patch application as a kind of content change"""
37
def __init__(self, contents):
38
"""Constructor.
39
40
:param contents: The text of the patch to apply
41
:type contents: str"""
42
self.contents = contents
43
44
def __eq__(self, other):
45
if not isinstance(other, PatchApply):
46
return False
47
elif self.contents != other.contents:
48
return False
49
else:
50
return True
51
52
def __ne__(self, other):
53
return not (self == other)
54
55
def apply(self, filename, conflict_handler, reverse=False):
56
"""Applies the patch to the specified file.
57
58
:param filename: the file to apply the patch to
59
:type filename: str
60
:param reverse: If true, apply the patch in reverse
61
:type reverse: bool
62
"""
63
input_name = filename+".orig"
64
try:
65
os.rename(filename, input_name)
66
except OSError, e:
67
if e.errno != errno.ENOENT:
68
raise
69
if conflict_handler.patch_target_missing(filename, self.contents)\
70
== "skip":
71
return
72
os.rename(filename, input_name)
73
74
75
status = patch.patch(self.contents, input_name, filename,
76
reverse)
77
os.chmod(filename, os.stat(input_name).st_mode)
78
if status == 0:
79
os.unlink(input_name)
80
elif status == 1:
81
conflict_handler.failed_hunks(filename)
82
83
47
84
class ChangeUnixPermissions(object):
48
85
"""This is two-way change, suitable for file modification, creation,
49
86
deletion"""
326
363
327
364
328
365
class Diff3Merge(object):
329
def __init__(self, file_id, base, other):
330
self.file_id = file_id
331
self.base = base
332
self.other = other
366
def __init__(self, base_file, other_file):
367
self.base_file = base_file
368
self.other_file = other_file
333
369
334
370
def __eq__(self, other):
335
371
if not isinstance(other, Diff3Merge):
336
372
return False
337
return (self.base == other.base and
338
self.other == other.other and self.file_id == other.file_id)
373
return (self.base_file == other.base_file and
374
self.other_file == other.other_file)
339
375
340
376
def __ne__(self, other):
341
377
return not (self == other)
342
378
343
379
def apply(self, filename, conflict_handler, reverse=False):
344
new_file = filename+".new"
345
base_file = self.base.readonly_path(self.file_id)
346
other_file = self.other.readonly_path(self.file_id)
380
new_file = filename+".new"
347
381
if not reverse:
348
base = base_file
349
other = other_file
382
base = self.base_file
383
other = self.other_file
350
384
else:
351
base = other_file
352
other = base_file
385
base = self.other_file
386
other = self.base_file
353
387
status = patch.diff3(new_file, filename, base, other)
354
388
if status == 0:
355
389
os.chmod(new_file, os.stat(filename).st_mode)
357
391
return
358
392
else:
359
393
assert(status == 1)
360
def get_lines(filename):
361
my_file = file(base, "rb")
362
lines = my_file.readlines()
363
my_file.close()
364
base_lines = get_lines(base)
365
other_lines = get_lines(other)
366
conflict_handler.merge_conflict(new_file, filename, base_lines,
367
other_lines)
394
conflict_handler.merge_conflict(new_file, filename, base, other)
368
395
369
396
370
397
def CreateDir():
626
653
return None
627
654
return self.path
628
655
629
def summarize_name(self, reverse=False):
656
def summarize_name(self, changeset, reverse=False):
630
657
"""Produce a one-line summary of the filename. Indicates renames as
631
658
old => new, indicates creation as None => new, indicates deletion as
632
659
old => None.
663
690
:type reverse: bool
664
691
:rtype: str
665
692
"""
666
mutter("Finding new path for %s" % self.summarize_name())
667
693
if reverse:
668
694
parent = self.parent
669
695
to_dir = self.dir
688
714
if from_dir == to_dir:
689
715
dir = os.path.dirname(id_map[self.id])
690
716
else:
691
mutter("path, new_path: %r %r" % (self.path, self.new_path))
692
717
parent_entry = changeset.entries[parent]
693
718
dir = parent_entry.get_new_path(id_map, changeset, reverse)
694
719
if from_name == to_name:
801
826
my_sort(target_entries, shortest_to_longest)
802
827
return (source_entries, target_entries)
803
828
804
def rename_to_temp_delete(source_entries, inventory, dir, temp_dir,
805
conflict_handler, reverse):
829
def rename_to_temp_delete(source_entries, inventory, dir, conflict_handler,
830
reverse):
806
831
"""Delete and rename entries as appropriate. Entries are renamed to temp
807
names. A map of id -> temp name (or None, for deletions) is returned.
832
names. A map of id -> temp name is returned.
808
833
809
834
:param source_entries: The entries to rename and delete
810
835
:type source_entries: List of `ChangesetEntry`
817
842
:return: a mapping of id to temporary name
818
843
:rtype: Dictionary
819
844
"""
845
temp_dir = os.path.join(dir, "temp")
820
846
temp_name = {}
821
847
for i in range(len(source_entries)):
822
848
entry = source_entries[i]
823
849
if entry.is_deletion(reverse):
824
850
path = os.path.join(dir, inventory[entry.id])
825
851
entry.apply(path, conflict_handler, reverse)
826
temp_name[entry.id] = None
827
852
828
853
else:
829
to_name = os.path.join(temp_dir, str(i))
854
to_name = temp_dir+"/"+str(i)
830
855
src_path = inventory.get(entry.id)
831
856
if src_path is not None:
832
857
src_path = os.path.join(dir, src_path)
842
867
return temp_name
843
868
844
869
845
def rename_to_new_create(changed_inventory, target_entries, inventory,
846
changeset, dir, conflict_handler, reverse):
870
def rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
871
conflict_handler, reverse):
847
872
"""Rename entries with temp names to their final names, create new files.
848
873
849
:param changed_inventory: A mapping of id to temporary name
850
:type changed_inventory: Dictionary
874
:param temp_name: A mapping of id to temporary name
875
:type temp_name: Dictionary
851
876
:param target_entries: The entries to apply changes to
852
877
:type target_entries: List of `ChangesetEntry`
853
878
:param changeset: The changeset to apply
858
883
:type reverse: bool
859
884
"""
860
885
for entry in target_entries:
861
new_tree_path = entry.get_new_path(inventory, changeset, reverse)
862
if new_tree_path is None:
886
new_path = entry.get_new_path(inventory, changeset, reverse)
887
if new_path is None:
863
888
continue
864
new_path = os.path.join(dir, new_tree_path)
865
old_path = changed_inventory.get(entry.id)
889
new_path = os.path.join(dir, new_path)
890
old_path = temp_name.get(entry.id)
866
891
if os.path.exists(new_path):
867
892
if conflict_handler.target_exists(entry, new_path, old_path) == \
868
893
"skip":
869
894
continue
870
895
if entry.is_creation(reverse):
871
896
entry.apply(new_path, conflict_handler, reverse)
872
changed_inventory[entry.id] = new_tree_path
873
897
else:
874
898
if old_path is None:
875
899
continue
876
900
try:
877
901
os.rename(old_path, new_path)
878
changed_inventory[entry.id] = new_tree_path
879
902
except OSError, e:
880
903
raise Exception ("%s is missing" % new_path)
881
904
983
1006
Exception.__init__(self, msg)
984
1007
self.filename = filename
985
1008
986
class NewContentsConflict(Exception):
987
def __init__(self, filename):
988
msg = "Conflicting contents for new file %s" % (filename)
989
Exception.__init__(self, msg)
990
991
992
class MissingForMerge(Exception):
993
def __init__(self, filename):
994
msg = "The file %s was modified, but does not exist in this tree"\
995
% (filename)
996
Exception.__init__(self, msg)
997
998
999
1009
class ExceptionConflictHandler(object):
1000
"""Default handler for merge exceptions.
1001
1002
This throws an error on any kind of conflict. Conflict handlers can
1003
descend from this class if they have a better way to handle some or
1004
all types of conflict.
1005
"""
1010
def __init__(self, dir):
1011
self.dir = dir
1012
1006
1013
def missing_parent(self, pathname):
1007
1014
parent = os.path.dirname(pathname)
1008
1015
raise Exception("Parent directory missing for %s" % pathname)
1019
1026
def rename_conflict(self, id, this_name, base_name, other_name):
1020
1027
raise RenameConflict(id, this_name, base_name, other_name)
1021
1028
1022
def move_conflict(self, id, this_dir, base_dir, other_dir):
1029
def move_conflict(self, id, inventory):
1030
this_dir = inventory.this.get_dir(id)
1031
base_dir = inventory.base.get_dir(id)
1032
other_dir = inventory.other.get_dir(id)
1023
1033
raise MoveConflict(id, this_dir, base_dir, other_dir)
1024
1034
1025
def merge_conflict(self, new_file, this_path, base_lines, other_lines):
1035
def merge_conflict(self, new_file, this_path, base_path, other_path):
1026
1036
os.unlink(new_file)
1027
1037
raise MergeConflict(this_path)
1028
1038
1056
1066
def missing_for_rename(self, filename):
1057
1067
raise MissingForRename(filename)
1058
1068
1059
def missing_for_merge(self, file_id, other_path):
1060
raise MissingForMerge(other_path)
1061
1062
def new_contents_conflict(self, filename, other_contents):
1063
raise NewContentsConflict(filename)
1064
1065
def finalize(self):
1066
pass
1067
1068
1069
def apply_changeset(changeset, inventory, dir, conflict_handler=None,
1069
1070
reverse=False):
1070
1071
"""Apply a changeset to a directory.
1081
1082
:rtype: Dictionary
1082
1083
"""
1083
1084
if conflict_handler is None:
1084
conflict_handler = ExceptionConflictHandler()
1085
temp_dir = os.path.join(dir, "bzr-tree-change")
1086
try:
1087
os.mkdir(temp_dir)
1088
except OSError, e:
1089
if e.errno == errno.EEXIST:
1090
try:
1091
os.rmdir(temp_dir)
1092
except OSError, e:
1093
if e.errno == errno.ENOTEMPTY:
1094
raise OldFailedTreeOp()
1095
os.mkdir(temp_dir)
1096
else:
1097
raise
1085
conflict_handler = ExceptionConflictHandler(dir)
1086
temp_dir = dir+"/temp"
1087
os.mkdir(temp_dir)
1098
1088
1099
1089
#apply changes that don't affect filenames
1100
1090
for entry in changeset.entries.itervalues():
1109
1099
(source_entries, target_entries) = get_rename_entries(changeset, inventory,
1110
1100
reverse)
1111
1101
1112
changed_inventory = rename_to_temp_delete(source_entries, inventory, dir,
1113
temp_dir, conflict_handler,
1114
reverse)
1102
temp_name = rename_to_temp_delete(source_entries, inventory, dir,
1103
conflict_handler, reverse)
1115
1104
1116
rename_to_new_create(changed_inventory, target_entries, inventory,
1117
changeset, dir, conflict_handler, reverse)
1105
rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
1106
conflict_handler, reverse)
1118
1107
os.rmdir(temp_dir)
1119
return changed_inventory
1108
r_inventory = invert_dict(inventory)
1109
new_entries, removed_entries = get_inventory_change(inventory,
1110
r_inventory, changeset, reverse)
1111
new_inventory = {}
1112
for path, file_id in new_entries.iteritems():
1113
new_inventory[file_id] = path
1114
for file_id in removed_entries:
1115
new_inventory[file_id] = None
1116
return new_inventory
1120
1117
1121
1118
1122
1119
def apply_changeset_tree(cset, tree, reverse=False):
1133
1130
def get_inventory_change(inventory, new_inventory, cset, reverse=False):
1134
1131
new_entries = {}
1135
1132
remove_entries = []
1133
r_inventory = invert_dict(inventory)
1134
r_new_inventory = invert_dict(new_inventory)
1136
1135
for entry in cset.entries.itervalues():
1137
1136
if entry.needs_rename():
1138
new_path = entry.get_new_path(inventory, cset)
1139
if new_path is None:
1140
remove_entries.append(entry.id)
1137
old_path = r_inventory.get(entry.id)
1138
if old_path is not None:
1139
remove_entries.append(old_path)
1141
1140
else:
1142
new_entries[new_path] = entry.id
1141
new_path = entry.get_new_path(inventory, cset)
1142
if new_path is not None:
1143
new_entries[new_path] = entry.id
1143
1144
return new_entries, remove_entries
1144
1145
1145
1146
1284
1285
self.full_path = full_path
1285
1286
self.stat_result = stat_result
1286
1287
1287
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1288
return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1288
def generate_changeset(tree_a, tree_b, inventory_a=None, inventory_b=None):
1289
return ChangesetGenerator(tree_a, tree_b, inventory_a, inventory_b)()
1289
1290
1290
1291
class ChangesetGenerator(object):
1291
def __init__(self, tree_a, tree_b, interesting_ids=None):
1292
def __init__(self, tree_a, tree_b, inventory_a=None, inventory_b=None):
1292
1293
object.__init__(self)
1293
1294
self.tree_a = tree_a
1294
1295
self.tree_b = tree_b
1295
self._interesting_ids = interesting_ids
1296
if inventory_a is not None:
1297
self.inventory_a = inventory_a
1298
else:
1299
self.inventory_a = tree_a.inventory()
1300
if inventory_b is not None:
1301
self.inventory_b = inventory_b
1302
else:
1303
self.inventory_b = tree_b.inventory()
1304
self.r_inventory_a = self.reverse_inventory(self.inventory_a)
1305
self.r_inventory_b = self.reverse_inventory(self.inventory_b)
1296
1306
1297
def iter_both_tree_ids(self):
1298
for file_id in self.tree_a:
1299
yield file_id
1300
for file_id in self.tree_b:
1301
if file_id not in self.tree_a:
1302
yield file_id
1307
def reverse_inventory(self, inventory):
1308
r_inventory = {}
1309
for entry in inventory.itervalues():
1310
if entry.id is None:
1311
continue
1312
r_inventory[entry.id] = entry
1313
return r_inventory
1303
1314
1304
1315
def __call__(self):
1305
1316
cset = Changeset()
1306
for file_id in self.iter_both_tree_ids():
1307
cs_entry = self.make_entry(file_id)
1317
for entry in self.inventory_a.itervalues():
1318
if entry.id is None:
1319
continue
1320
cs_entry = self.make_entry(entry.id)
1308
1321
if cs_entry is not None and not cs_entry.is_boring():
1309
1322
cset.add_entry(cs_entry)
1310
1323
1324
for entry in self.inventory_b.itervalues():
1325
if entry.id is None:
1326
continue
1327
if not self.r_inventory_a.has_key(entry.id):
1328
cs_entry = self.make_entry(entry.id)
1329
if cs_entry is not None and not cs_entry.is_boring():
1330
cset.add_entry(cs_entry)
1311
1331
for entry in list(cset.entries.itervalues()):
1312
1332
if entry.parent != entry.new_parent:
1313
1333
if not cset.entries.has_key(entry.parent) and\
1321
1341
cset.add_entry(parent_entry)
1322
1342
return cset
1323
1343
1324
def iter_inventory(self, tree):
1325
for file_id in tree:
1326
yield self.get_entry(file_id, tree)
1327
1328
def get_entry(self, file_id, tree):
1329
if not tree.has_or_had_id(file_id):
1330
return None
1331
return tree.tree.inventory[file_id]
1332
1333
def get_entry_parent(self, entry):
1334
if entry is None:
1335
return None
1336
return entry.parent_id
1337
1338
def get_path(self, file_id, tree):
1339
if not tree.has_or_had_id(file_id):
1340
return None
1341
path = tree.id2path(file_id)
1342
if path == '':
1343
return './.'
1344
else:
1345
return path
1346
1347
def make_basic_entry(self, file_id, only_interesting):
1348
entry_a = self.get_entry(file_id, self.tree_a)
1349
entry_b = self.get_entry(file_id, self.tree_b)
1344
def get_entry_parent(self, entry, inventory):
1345
if entry is None:
1346
return None
1347
if entry.path == "./.":
1348
return NULL_ID
1349
dirname = os.path.dirname(entry.path)
1350
if dirname == ".":
1351
dirname = "./."
1352
parent = inventory[dirname]
1353
return parent.id
1354
1355
def get_paths(self, entry, tree):
1356
if entry is None:
1357
return (None, None)
1358
full_path = tree.readonly_path(entry.id)
1359
if entry.path == ".":
1360
return ("", full_path)
1361
return (entry.path, full_path)
1362
1363
def make_basic_entry(self, id, only_interesting):
1364
entry_a = self.r_inventory_a.get(id)
1365
entry_b = self.r_inventory_b.get(id)
1350
1366
if only_interesting and not self.is_interesting(entry_a, entry_b):
1351
return None
1352
parent = self.get_entry_parent(entry_a)
1353
path = self.get_path(file_id, self.tree_a)
1354
cs_entry = ChangesetEntry(file_id, parent, path)
1355
new_parent = self.get_entry_parent(entry_b)
1356
1357
new_path = self.get_path(file_id, self.tree_b)
1367
return (None, None, None)
1368
parent = self.get_entry_parent(entry_a, self.inventory_a)
1369
(path, full_path_a) = self.get_paths(entry_a, self.tree_a)
1370
cs_entry = ChangesetEntry(id, parent, path)
1371
new_parent = self.get_entry_parent(entry_b, self.inventory_b)
1372
1373
1374
(new_path, full_path_b) = self.get_paths(entry_b, self.tree_b)
1358
1375
1359
1376
cs_entry.new_path = new_path
1360
1377
cs_entry.new_parent = new_parent
1361
return cs_entry
1378
return (cs_entry, full_path_a, full_path_b)
1362
1379
1363
1380
def is_interesting(self, entry_a, entry_b):
1364
if self._interesting_ids is None:
1365
return True
1366
1381
if entry_a is not None:
1367
file_id = entry_a.file_id
1368
elif entry_b is not None:
1369
file_id = entry_b.file_id
1370
else:
1371
return False
1372
return file_id in self._interesting_ids
1382
if entry_a.interesting:
1383
return True
1384
if entry_b is not None:
1385
if entry_b.interesting:
1386
return True
1387
return False
1373
1388
1374
1389
def make_boring_entry(self, id):
1375
cs_entry = self.make_basic_entry(id, only_interesting=False)
1390
(cs_entry, full_path_a, full_path_b) = \
1391
self.make_basic_entry(id, only_interesting=False)
1376
1392
if cs_entry.is_creation_or_deletion():
1377
1393
return self.make_entry(id, only_interesting=False)
1378
1394
else:
1380
1396
1381
1397
1382
1398
def make_entry(self, id, only_interesting=True):
1383
cs_entry = self.make_basic_entry(id, only_interesting)
1399
(cs_entry, full_path_a, full_path_b) = \
1400
self.make_basic_entry(id, only_interesting)
1384
1401
1385
1402
if cs_entry is None:
1386
1403
return None
1387
if id in self.tree_a and id in self.tree_b:
1388
a_sha1 = self.tree_a.get_file_sha1(id)
1389
b_sha1 = self.tree_b.get_file_sha1(id)
1390
if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1391
return cs_entry
1392
1393
full_path_a = self.tree_a.readonly_path(id)
1394
full_path_b = self.tree_b.readonly_path(id)
1404
1395
1405
stat_a = self.lstat(full_path_a)
1396
1406
stat_b = self.lstat(full_path_b)
1407
if stat_b is None:
1408
cs_entry.new_parent = None
1409
cs_entry.new_path = None
1397
1410
1398
1411
cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
1399
1412
cs_entry.contents_change = self.make_contents_change(full_path_a,
1424
1437
if stat_a.st_ino == stat_b.st_ino and \
1425
1438
stat_a.st_dev == stat_b.st_dev:
1426
1439
return None
1440
if file(full_path_a, "rb").read() == \
1441
file(full_path_b, "rb").read():
1442
return None
1443
1444
patch_contents = patch.diff(full_path_a,
1445
file(full_path_b, "rb").read())
1446
if patch_contents is None:
1447
return None
1448
return PatchApply(patch_contents)
1427
1449
1428
1450
a_contents = self.get_contents(stat_a, full_path_a)
1429
1451
b_contents = self.get_contents(stat_b, full_path_b)
1477
1499
1478
1500
1479
1501
1480
# XXX: Can't we unify this with the regular inventory object
1502
1481
1503
class Inventory(object):
1482
1504
def __init__(self, inventory):
1483
1505
self.inventory = inventory
1492
1514
return self.inventory.get(id)
1493
1515
1494
1516
def get_name(self, id):
1495
path = self.get_path(id)
1496
if path is None:
1497
return None
1498
else:
1499
return os.path.basename(path)
1517
return os.path.basename(self.get_path(id))
1500
1518
1501
1519
def get_dir(self, id):
1502
1520
path = self.get_path(id)
1503
1521
if path == "":
1504
1522
return None
1505
if path is None:
1506
return None
1507
1523
return os.path.dirname(path)
1508
1524
1509
1525
def get_parent(self, id):
1510
if self.get_path(id) is None:
1511
return None
1512
1526
directory = self.get_dir(id)
1513
1527
if directory == '.':
1514
1528
directory = './.'
Loggerhead is a web-based interface for Breezy
Version: 2.0.1