~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/changeset.py

  • Committer: Aaron Bentley
  • Date: 2005-08-10 21:43:27 UTC
  • mto: (1092.1.41) (1185.3.4) (974.1.47)
  • mto: This revision was merged to the branch mainline in revision 1110.
  • Revision ID: abentley@panoramicfeedback.com-20050810214327-4e8c22e4cba24527
Eliminated ThreeWayInventory

Show diffs side-by-side

added added

removed removed

Lines of Context:
17
17
import errno
18
18
import patch
19
19
import stat
 
20
from bzrlib.trace import mutter
20
21
"""
21
22
Represent and apply a changeset
22
23
"""
24
25
 
25
26
NULL_ID = "!NULL"
26
27
 
27
 
 
 
28
class OldFailedTreeOp(Exception):
 
29
    def __init__(self):
 
30
        Exception.__init__(self, "bzr-tree-change contains files from a"
 
31
                           " previous failed merge operation.")
28
32
def invert_dict(dict):
29
33
    newdict = {}
30
34
    for (key,value) in dict.iteritems():
32
36
    return newdict
33
37
 
34
38
 
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
 
        
 
39
       
84
40
class ChangeUnixPermissions(object):
85
41
    """This is two-way change, suitable for file modification, creation,
86
42
    deletion"""
690
646
        :type reverse: bool
691
647
        :rtype: str
692
648
        """
 
649
        mutter("Finding new path for %s" % self.summarize_name(changeset))
693
650
        if reverse:
694
651
            parent = self.parent
695
652
            to_dir = self.dir
714
671
        if from_dir == to_dir:
715
672
            dir = os.path.dirname(id_map[self.id])
716
673
        else:
 
674
            mutter("path, new_path: %r %r" % (self.path, self.new_path))
717
675
            parent_entry = changeset.entries[parent]
718
676
            dir = parent_entry.get_new_path(id_map, changeset, reverse)
719
677
        if from_name == to_name:
826
784
    my_sort(target_entries, shortest_to_longest)
827
785
    return (source_entries, target_entries)
828
786
 
829
 
def rename_to_temp_delete(source_entries, inventory, dir, conflict_handler,
830
 
                          reverse):
 
787
def rename_to_temp_delete(source_entries, inventory, dir, temp_dir, 
 
788
                          conflict_handler, reverse):
831
789
    """Delete and rename entries as appropriate.  Entries are renamed to temp
832
 
    names.  A map of id -> temp name is returned.
 
790
    names.  A map of id -> temp name (or None, for deletions) is returned.
833
791
 
834
792
    :param source_entries: The entries to rename and delete
835
793
    :type source_entries: List of `ChangesetEntry`
842
800
    :return: a mapping of id to temporary name
843
801
    :rtype: Dictionary
844
802
    """
845
 
    temp_dir = os.path.join(dir, "temp")
846
803
    temp_name = {}
847
804
    for i in range(len(source_entries)):
848
805
        entry = source_entries[i]
849
806
        if entry.is_deletion(reverse):
850
807
            path = os.path.join(dir, inventory[entry.id])
851
808
            entry.apply(path, conflict_handler, reverse)
 
809
            temp_name[entry.id] = None
852
810
 
853
811
        else:
854
 
            to_name = temp_dir+"/"+str(i)
 
812
            to_name = os.path.join(temp_dir, str(i))
855
813
            src_path = inventory.get(entry.id)
856
814
            if src_path is not None:
857
815
                src_path = os.path.join(dir, src_path)
867
825
    return temp_name
868
826
 
869
827
 
870
 
def rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
871
 
                         conflict_handler, reverse):
 
828
def rename_to_new_create(changed_inventory, target_entries, inventory, 
 
829
                         changeset, dir, conflict_handler, reverse):
872
830
    """Rename entries with temp names to their final names, create new files.
873
831
 
874
 
    :param temp_name: A mapping of id to temporary name
875
 
    :type temp_name: Dictionary
 
832
    :param changed_inventory: A mapping of id to temporary name
 
833
    :type changed_inventory: Dictionary
876
834
    :param target_entries: The entries to apply changes to
877
835
    :type target_entries: List of `ChangesetEntry`
878
836
    :param changeset: The changeset to apply
883
841
    :type reverse: bool
884
842
    """
885
843
    for entry in target_entries:
886
 
        new_path = entry.get_new_path(inventory, changeset, reverse)
887
 
        if new_path is None:
 
844
        new_tree_path = entry.get_new_path(inventory, changeset, reverse)
 
845
        if new_tree_path is None:
888
846
            continue
889
 
        new_path = os.path.join(dir, new_path)
890
 
        old_path = temp_name.get(entry.id)
 
847
        new_path = os.path.join(dir, new_tree_path)
 
848
        old_path = changed_inventory.get(entry.id)
891
849
        if os.path.exists(new_path):
892
850
            if conflict_handler.target_exists(entry, new_path, old_path) == \
893
851
                "skip":
894
852
                continue
895
853
        if entry.is_creation(reverse):
896
854
            entry.apply(new_path, conflict_handler, reverse)
 
855
            changed_inventory[entry.id] = new_tree_path
897
856
        else:
898
857
            if old_path is None:
899
858
                continue
900
859
            try:
901
860
                os.rename(old_path, new_path)
 
861
                changed_inventory[entry.id] = new_tree_path
902
862
            except OSError, e:
903
863
                raise Exception ("%s is missing" % new_path)
904
864
 
1006
966
        Exception.__init__(self, msg)
1007
967
        self.filename = filename
1008
968
 
 
969
class NewContentsConflict(Exception):
 
970
    def __init__(self, filename):
 
971
        msg = "Conflicting contents for new file %s" % (filename)
 
972
        Exception.__init__(self, msg)
 
973
 
 
974
 
 
975
class MissingForMerge(Exception):
 
976
    def __init__(self, filename):
 
977
        msg = "The file %s was modified, but does not exist in this tree"\
 
978
            % (filename)
 
979
        Exception.__init__(self, msg)
 
980
 
 
981
 
1009
982
class ExceptionConflictHandler(object):
1010
983
    def __init__(self, dir):
1011
984
        self.dir = dir
1026
999
    def rename_conflict(self, id, this_name, base_name, other_name):
1027
1000
        raise RenameConflict(id, this_name, base_name, other_name)
1028
1001
 
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)
 
1002
    def move_conflict(self, id, this_dir, base_dir, other_dir):
1033
1003
        raise MoveConflict(id, this_dir, base_dir, other_dir)
1034
1004
 
1035
1005
    def merge_conflict(self, new_file, this_path, base_path, other_path):
1066
1036
    def missing_for_rename(self, filename):
1067
1037
        raise MissingForRename(filename)
1068
1038
 
 
1039
    def missing_for_merge(self, file_id, other_path):
 
1040
        raise MissingForMerge(other_path)
 
1041
 
 
1042
    def new_contents_conflict(self, filename, other_contents):
 
1043
        raise NewContentsConflict(filename)
 
1044
 
1069
1045
    def finalize():
1070
1046
        pass
1071
1047
 
1086
1062
    """
1087
1063
    if conflict_handler is None:
1088
1064
        conflict_handler = ExceptionConflictHandler(dir)
1089
 
    temp_dir = dir+"/temp"
1090
 
    os.mkdir(temp_dir)
 
1065
    temp_dir = os.path.join(dir, "bzr-tree-change")
 
1066
    try:
 
1067
        os.mkdir(temp_dir)
 
1068
    except OSError, e:
 
1069
        if e.errno == errno.EEXIST:
 
1070
            try:
 
1071
                os.rmdir(temp_dir)
 
1072
            except OSError, e:
 
1073
                if e.errno == errno.ENOTEMPTY:
 
1074
                    raise OldFailedTreeOp()
 
1075
            os.mkdir(temp_dir)
 
1076
        else:
 
1077
            raise
1091
1078
    
1092
1079
    #apply changes that don't affect filenames
1093
1080
    for entry in changeset.entries.itervalues():
1102
1089
    (source_entries, target_entries) = get_rename_entries(changeset, inventory,
1103
1090
                                                          reverse)
1104
1091
 
1105
 
    temp_name = rename_to_temp_delete(source_entries, inventory, dir,
1106
 
                                      conflict_handler, reverse)
 
1092
    changed_inventory = rename_to_temp_delete(source_entries, inventory, dir,
 
1093
                                              temp_dir, conflict_handler,
 
1094
                                              reverse)
1107
1095
 
1108
 
    rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
1109
 
                         conflict_handler, reverse)
 
1096
    rename_to_new_create(changed_inventory, target_entries, inventory,
 
1097
                         changeset, dir, conflict_handler, reverse)
1110
1098
    os.rmdir(temp_dir)
1111
 
    r_inventory = invert_dict(inventory)
1112
 
    new_entries, removed_entries = get_inventory_change(inventory,
1113
 
    r_inventory, changeset, reverse)
1114
 
    new_inventory = {}
1115
 
    for path, file_id in new_entries.iteritems():
1116
 
        new_inventory[file_id] = path
1117
 
    for file_id in removed_entries:
1118
 
        new_inventory[file_id] = None
1119
 
    return new_inventory
 
1099
    return changed_inventory
1120
1100
 
1121
1101
 
1122
1102
def apply_changeset_tree(cset, tree, reverse=False):
1133
1113
def get_inventory_change(inventory, new_inventory, cset, reverse=False):
1134
1114
    new_entries = {}
1135
1115
    remove_entries = []
1136
 
    r_inventory = invert_dict(inventory)
1137
 
    r_new_inventory = invert_dict(new_inventory)
1138
1116
    for entry in cset.entries.itervalues():
1139
1117
        if entry.needs_rename():
1140
 
            old_path = r_inventory.get(entry.id)
1141
 
            if old_path is not None:
1142
 
                remove_entries.append(old_path)
 
1118
            new_path = entry.get_new_path(inventory, cset)
 
1119
            if new_path is None:
 
1120
                remove_entries.append(entry.id)
1143
1121
            else:
1144
 
                new_path = entry.get_new_path(inventory, cset)
1145
 
                if new_path is not None:
1146
 
                    new_entries[new_path] = entry.id
 
1122
                new_entries[new_path] = entry.id
1147
1123
    return new_entries, remove_entries
1148
1124
 
1149
1125
 
1288
1264
        self.full_path = full_path
1289
1265
        self.stat_result = stat_result
1290
1266
 
1291
 
def generate_changeset(tree_a, tree_b, inventory_a=None, inventory_b=None):
1292
 
    return ChangesetGenerator(tree_a, tree_b, inventory_a, inventory_b)()
 
1267
def generate_changeset(tree_a, tree_b, interesting_ids=None):
 
1268
    return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1293
1269
 
1294
1270
class ChangesetGenerator(object):
1295
 
    def __init__(self, tree_a, tree_b, inventory_a=None, inventory_b=None):
 
1271
    def __init__(self, tree_a, tree_b, interesting_ids=None):
1296
1272
        object.__init__(self)
1297
1273
        self.tree_a = tree_a
1298
1274
        self.tree_b = tree_b
1299
 
        if inventory_a is not None:
1300
 
            self.inventory_a = inventory_a
1301
 
        else:
1302
 
            self.inventory_a = tree_a.inventory()
1303
 
        if inventory_b is not None:
1304
 
            self.inventory_b = inventory_b
1305
 
        else:
1306
 
            self.inventory_b = tree_b.inventory()
1307
 
        self.r_inventory_a = self.reverse_inventory(self.inventory_a)
1308
 
        self.r_inventory_b = self.reverse_inventory(self.inventory_b)
 
1275
        self._interesting_ids = interesting_ids
1309
1276
 
1310
 
    def reverse_inventory(self, inventory):
1311
 
        r_inventory = {}
1312
 
        for entry in inventory.itervalues():
1313
 
            if entry.id is None:
1314
 
                continue
1315
 
            r_inventory[entry.id] = entry
1316
 
        return r_inventory
 
1277
    def iter_both_tree_ids(self):
 
1278
        for file_id in self.tree_a:
 
1279
            yield file_id
 
1280
        for file_id in self.tree_b:
 
1281
            if file_id not in self.tree_a:
 
1282
                yield file_id
1317
1283
 
1318
1284
    def __call__(self):
1319
1285
        cset = Changeset()
1320
 
        for entry in self.inventory_a.itervalues():
1321
 
            if entry.id is None:
1322
 
                continue
1323
 
            cs_entry = self.make_entry(entry.id)
 
1286
        for file_id in self.iter_both_tree_ids():
 
1287
            cs_entry = self.make_entry(file_id)
1324
1288
            if cs_entry is not None and not cs_entry.is_boring():
1325
1289
                cset.add_entry(cs_entry)
1326
1290
 
1327
 
        for entry in self.inventory_b.itervalues():
1328
 
            if entry.id is None:
1329
 
                continue
1330
 
            if not self.r_inventory_a.has_key(entry.id):
1331
 
                cs_entry = self.make_entry(entry.id)
1332
 
                if cs_entry is not None and not cs_entry.is_boring():
1333
 
                    cset.add_entry(cs_entry)
1334
1291
        for entry in list(cset.entries.itervalues()):
1335
1292
            if entry.parent != entry.new_parent:
1336
1293
                if not cset.entries.has_key(entry.parent) and\
1344
1301
                    cset.add_entry(parent_entry)
1345
1302
        return cset
1346
1303
 
1347
 
    def get_entry_parent(self, entry, inventory):
1348
 
        if entry is None:
1349
 
            return None
1350
 
        if entry.path == "./.":
1351
 
            return NULL_ID
1352
 
        dirname = os.path.dirname(entry.path)
1353
 
        if dirname == ".":
1354
 
            dirname = "./."
1355
 
        parent = inventory[dirname]
1356
 
        return parent.id
1357
 
 
1358
 
    def get_paths(self, entry, tree):
1359
 
        if entry is None:
1360
 
            return (None, None)
1361
 
        full_path = tree.readonly_path(entry.id)
1362
 
        if entry.path == ".":
1363
 
            return ("", full_path)
1364
 
        return (entry.path, full_path)
1365
 
 
1366
 
    def make_basic_entry(self, id, only_interesting):
1367
 
        entry_a = self.r_inventory_a.get(id)
1368
 
        entry_b = self.r_inventory_b.get(id)
 
1304
    def iter_inventory(self, tree):
 
1305
        for file_id in tree:
 
1306
            yield self.get_entry(file_id, tree)
 
1307
 
 
1308
    def get_entry(self, file_id, tree):
 
1309
        if file_id not in tree:
 
1310
            return None
 
1311
        return tree.tree.inventory[file_id]
 
1312
 
 
1313
    def get_entry_parent(self, entry):
 
1314
        if entry is None:
 
1315
            return None
 
1316
        return entry.parent_id
 
1317
 
 
1318
    def get_path(self, file_id, tree):
 
1319
        if not tree.has_id(file_id):
 
1320
            return None
 
1321
        path = tree.id2path(file_id)
 
1322
        if path == '':
 
1323
            return './.'
 
1324
        else:
 
1325
            return path
 
1326
 
 
1327
    def make_basic_entry(self, file_id, only_interesting):
 
1328
        entry_a = self.get_entry(file_id, self.tree_a)
 
1329
        entry_b = self.get_entry(file_id, self.tree_b)
1369
1330
        if only_interesting and not self.is_interesting(entry_a, entry_b):
1370
 
            return (None, None, None)
1371
 
        parent = self.get_entry_parent(entry_a, self.inventory_a)
1372
 
        (path, full_path_a) = self.get_paths(entry_a, self.tree_a)
1373
 
        cs_entry = ChangesetEntry(id, parent, path)
1374
 
        new_parent = self.get_entry_parent(entry_b, self.inventory_b)
1375
 
 
1376
 
 
1377
 
        (new_path, full_path_b) = self.get_paths(entry_b, self.tree_b)
 
1331
            return None
 
1332
        parent = self.get_entry_parent(entry_a)
 
1333
        path = self.get_path(file_id, self.tree_a)
 
1334
        cs_entry = ChangesetEntry(file_id, parent, path)
 
1335
        new_parent = self.get_entry_parent(entry_b)
 
1336
 
 
1337
        new_path = self.get_path(file_id, self.tree_b)
1378
1338
 
1379
1339
        cs_entry.new_path = new_path
1380
1340
        cs_entry.new_parent = new_parent
1381
 
        return (cs_entry, full_path_a, full_path_b)
 
1341
        return cs_entry
1382
1342
 
1383
1343
    def is_interesting(self, entry_a, entry_b):
 
1344
        if self._interesting_ids is None:
 
1345
            return True
1384
1346
        if entry_a is not None:
1385
 
            if entry_a.interesting:
1386
 
                return True
1387
 
        if entry_b is not None:
1388
 
            if entry_b.interesting:
1389
 
                return True
1390
 
        return False
 
1347
            file_id = entry_a.file_id
 
1348
        elif entry_b is not None:
 
1349
            file_id = entry_b.file_id
 
1350
        else:
 
1351
            return False
 
1352
        return file_id in self._interesting_ids
1391
1353
 
1392
1354
    def make_boring_entry(self, id):
1393
 
        (cs_entry, full_path_a, full_path_b) = \
1394
 
            self.make_basic_entry(id, only_interesting=False)
 
1355
        cs_entry = self.make_basic_entry(id, only_interesting=False)
1395
1356
        if cs_entry.is_creation_or_deletion():
1396
1357
            return self.make_entry(id, only_interesting=False)
1397
1358
        else:
1399
1360
        
1400
1361
 
1401
1362
    def make_entry(self, id, only_interesting=True):
1402
 
        (cs_entry, full_path_a, full_path_b) = \
1403
 
            self.make_basic_entry(id, only_interesting)
 
1363
        cs_entry = self.make_basic_entry(id, only_interesting)
1404
1364
 
1405
1365
        if cs_entry is None:
1406
1366
            return None
1407
 
       
 
1367
        if id in self.tree_a and id in self.tree_b:
 
1368
            a_sha1 = self.tree_a.get_file_sha1(id)
 
1369
            b_sha1 = self.tree_b.get_file_sha1(id)
 
1370
            if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
 
1371
                return cs_entry
 
1372
 
 
1373
        full_path_a = self.tree_a.readonly_path(id)
 
1374
        full_path_b = self.tree_b.readonly_path(id)
1408
1375
        stat_a = self.lstat(full_path_a)
1409
1376
        stat_b = self.lstat(full_path_b)
1410
1377
        if stat_b is None:
1440
1407
            if stat_a.st_ino == stat_b.st_ino and \
1441
1408
                stat_a.st_dev == stat_b.st_dev:
1442
1409
                return None
1443
 
            if file(full_path_a, "rb").read() == \
1444
 
                file(full_path_b, "rb").read():
1445
 
                return None
1446
 
 
1447
 
            patch_contents = patch.diff(full_path_a, 
1448
 
                                        file(full_path_b, "rb").read())
1449
 
            if patch_contents is None:
1450
 
                return None
1451
 
            return PatchApply(patch_contents)
1452
1410
 
1453
1411
        a_contents = self.get_contents(stat_a, full_path_a)
1454
1412
        b_contents = self.get_contents(stat_b, full_path_b)
1502
1460
 
1503
1461
 
1504
1462
        
1505
 
    
 
1463
# XXX: Can't we unify this with the regular inventory object
1506
1464
class Inventory(object):
1507
1465
    def __init__(self, inventory):
1508
1466
        self.inventory = inventory
1517
1475
        return self.inventory.get(id)
1518
1476
 
1519
1477
    def get_name(self, id):
1520
 
        return os.path.basename(self.get_path(id))
 
1478
        path = self.get_path(id)
 
1479
        if path is None:
 
1480
            return None
 
1481
        else:
 
1482
            return os.path.basename(path)
1521
1483
 
1522
1484
    def get_dir(self, id):
1523
1485
        path = self.get_path(id)
1524
1486
        if path == "":
1525
1487
            return None
 
1488
        if path is None:
 
1489
            return None
1526
1490
        return os.path.dirname(path)
1527
1491
 
1528
1492
    def get_parent(self, id):
 
1493
        if self.get_path(id) is None:
 
1494
            return None
1529
1495
        directory = self.get_dir(id)
1530
1496
        if directory == '.':
1531
1497
            directory = './.'